From d34d85c04bb296da473973dbc4e332bf5306fbe6 Mon Sep 17 00:00:00 2001 From: Jonathan Naylor Date: Thu, 14 Jan 2016 18:45:04 +0000 Subject: [PATCH] Initial commit --- .gitignore | 12 + BPTC19696.cpp | 346 ++++++++++++ BPTC19696.h | 47 ++ CRC.cpp | 114 ++++ CRC.h | 35 ++ CSBK.cpp | 84 +++ CSBK.h | 58 ++ Conf.cpp | 494 +++++++++++++++++ Conf.h | 162 ++++++ DMRControl.cpp | 102 ++++ DMRControl.h | 53 ++ DMRData.cpp | 159 ++++++ DMRData.h | 62 +++ DMRDefines.h | 97 ++++ DMRSlot.cpp | 718 ++++++++++++++++++++++++ DMRSlot.h | 93 ++++ DMRSync.cpp | 155 ++++++ DMRSync.h | 56 ++ DStarDefines.h | 28 + DStarEcho.cpp | 74 +++ DStarEcho.h | 43 ++ Defines.h | 32 ++ Display.cpp | 23 + Display.h | 50 ++ EMB.cpp | 100 ++++ EMB.h | 47 ++ EmbeddedLC.cpp | 266 +++++++++ EmbeddedLC.h | 51 ++ FullLC.cpp | 101 ++++ FullLC.h | 42 ++ Golay2087.cpp | 262 +++++++++ Golay2087.h | 32 ++ Golay24128.cpp | 1092 +++++++++++++++++++++++++++++++++++++ Golay24128.h | 31 ++ Hamming.cpp | 228 ++++++++ Hamming.h | 37 ++ HomebrewDMRIPSC.cpp | 418 ++++++++++++++ HomebrewDMRIPSC.h | 107 ++++ Images/ALL.bmp | Bin 0 -> 461130 bytes Images/ALL_sm.bmp | Bin 0 -> 61494 bytes Images/DMR.bmp | Bin 0 -> 966222 bytes Images/DMR_sm.bmp | Bin 0 -> 34134 bytes Images/DStar.bmp | Bin 0 -> 895254 bytes Images/DStar_sm.bmp | Bin 0 -> 35574 bytes Images/MMDVM.bmp | Bin 0 -> 104686 bytes Images/MMDVM_sm.bmp | Bin 0 -> 14454 bytes Images/P25.bmp | Bin 0 -> 114534 bytes Images/P25_sm.bmp | Bin 0 -> 50454 bytes Images/Tetra.bmp | Bin 0 -> 151734 bytes Images/Tetra_sm.bmp | Bin 0 -> 37974 bytes Images/YSF.bmp | Bin 0 -> 60054 bytes Images/YSF_sm.bmp | Bin 0 -> 5814 bytes Images/dPMR.bmp | Bin 0 -> 151970 bytes Images/dPMR_sm.bmp | Bin 0 -> 40374 bytes LC.cpp | 183 +++++++ LC.h | 60 ++ LICENCE | 340 ++++++++++++ Log.cpp | 127 +++++ Log.h | 38 ++ MMDVM.ini | 70 +++ MMDVMHost.cpp | 473 ++++++++++++++++ MMDVMHost.h | 52 ++ MMDVMHost.sln | 28 + MMDVMHost.vcxproj | 228 ++++++++ MMDVMHost.vcxproj.filters | 236 ++++++++ Makefile | 120 ++++ Modem.cpp | 884 ++++++++++++++++++++++++++++++ Modem.h | 107 ++++ NullDisplay.cpp | 76 +++ NullDisplay.h | 53 ++ QR1676.cpp | 115 ++++ QR1676.h | 32 ++ README.md | 6 + RS129.cpp | 130 +++++ RS129.h | 30 + RingBuffer.h | 144 +++++ SHA256.cpp | 373 +++++++++++++ SHA256.h | 77 +++ SerialController.cpp | 467 ++++++++++++++++ SerialController.h | 73 +++ ShortLC.cpp | 220 ++++++++ ShortLC.h | 47 ++ SlotType.cpp | 92 ++++ SlotType.h | 42 ++ StopWatch.cpp | 85 +++ StopWatch.h | 46 ++ TFTSerial.cpp | 181 ++++++ TFTSerial.h | 55 ++ Timer.cpp | 68 +++ Timer.h | 89 +++ UDPSocket.cpp | 263 +++++++++ UDPSocket.h | 58 ++ Utils.cpp | 138 +++++ Utils.h | 36 ++ Version.h | 24 + YSFDefines.h | 33 ++ YSFEcho.cpp | 85 +++ YSFEcho.h | 43 ++ 98 files changed, 12038 insertions(+) create mode 100644 .gitignore create mode 100644 BPTC19696.cpp create mode 100644 BPTC19696.h create mode 100644 CRC.cpp create mode 100644 CRC.h create mode 100644 CSBK.cpp create mode 100644 CSBK.h create mode 100644 Conf.cpp create mode 100644 Conf.h create mode 100644 DMRControl.cpp create mode 100644 DMRControl.h create mode 100644 DMRData.cpp create mode 100644 DMRData.h create mode 100644 DMRDefines.h create mode 100644 DMRSlot.cpp create mode 100644 DMRSlot.h create mode 100644 DMRSync.cpp create mode 100644 DMRSync.h create mode 100644 DStarDefines.h create mode 100644 DStarEcho.cpp create mode 100644 DStarEcho.h create mode 100644 Defines.h create mode 100644 Display.cpp create mode 100644 Display.h create mode 100644 EMB.cpp create mode 100644 EMB.h create mode 100644 EmbeddedLC.cpp create mode 100644 EmbeddedLC.h create mode 100644 FullLC.cpp create mode 100644 FullLC.h create mode 100644 Golay2087.cpp create mode 100644 Golay2087.h create mode 100644 Golay24128.cpp create mode 100644 Golay24128.h create mode 100644 Hamming.cpp create mode 100644 Hamming.h create mode 100644 HomebrewDMRIPSC.cpp create mode 100644 HomebrewDMRIPSC.h create mode 100644 Images/ALL.bmp create mode 100644 Images/ALL_sm.bmp create mode 100644 Images/DMR.bmp create mode 100644 Images/DMR_sm.bmp create mode 100644 Images/DStar.bmp create mode 100644 Images/DStar_sm.bmp create mode 100644 Images/MMDVM.bmp create mode 100644 Images/MMDVM_sm.bmp create mode 100644 Images/P25.bmp create mode 100644 Images/P25_sm.bmp create mode 100644 Images/Tetra.bmp create mode 100644 Images/Tetra_sm.bmp create mode 100644 Images/YSF.bmp create mode 100644 Images/YSF_sm.bmp create mode 100644 Images/dPMR.bmp create mode 100644 Images/dPMR_sm.bmp create mode 100644 LC.cpp create mode 100644 LC.h create mode 100644 LICENCE create mode 100644 Log.cpp create mode 100644 Log.h create mode 100644 MMDVM.ini create mode 100644 MMDVMHost.cpp create mode 100644 MMDVMHost.h create mode 100644 MMDVMHost.sln create mode 100644 MMDVMHost.vcxproj create mode 100644 MMDVMHost.vcxproj.filters create mode 100644 Makefile create mode 100644 Modem.cpp create mode 100644 Modem.h create mode 100644 NullDisplay.cpp create mode 100644 NullDisplay.h create mode 100644 QR1676.cpp create mode 100644 QR1676.h create mode 100644 README.md create mode 100644 RS129.cpp create mode 100644 RS129.h create mode 100644 RingBuffer.h create mode 100644 SHA256.cpp create mode 100644 SHA256.h create mode 100644 SerialController.cpp create mode 100644 SerialController.h create mode 100644 ShortLC.cpp create mode 100644 ShortLC.h create mode 100644 SlotType.cpp create mode 100644 SlotType.h create mode 100644 StopWatch.cpp create mode 100644 StopWatch.h create mode 100644 TFTSerial.cpp create mode 100644 TFTSerial.h create mode 100644 Timer.cpp create mode 100644 Timer.h create mode 100644 UDPSocket.cpp create mode 100644 UDPSocket.h create mode 100644 Utils.cpp create mode 100644 Utils.h create mode 100644 Version.h create mode 100644 YSFDefines.h create mode 100644 YSFEcho.cpp create mode 100644 YSFEcho.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..378186f --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +Debug +Release +x64 +*.bak +*.obj +*~ +*.sdf +*.log +*.zip +*.exe +*.user +.vs diff --git a/BPTC19696.cpp b/BPTC19696.cpp new file mode 100644 index 0000000..7fbddef --- /dev/null +++ b/BPTC19696.cpp @@ -0,0 +1,346 @@ +/* + * Copyright (C) 2012 by Ian Wraith + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "BPTC19696.h" + +#include "Hamming.h" +#include "Utils.h" + +#include +#include +#include + +CBPTC19696::CBPTC19696() : +m_rawData(NULL), +m_deInterData(NULL) +{ + m_rawData = new bool[196]; + m_deInterData = new bool[196]; +} + +CBPTC19696::~CBPTC19696() +{ + delete[] m_rawData; + delete[] m_deInterData; +} + +// The main decode function +void CBPTC19696::decode(const unsigned char* in, unsigned char* out) +{ + assert(in != NULL); + assert(out != NULL); + + // Get the raw binary + decodeExtractBinary(in); + + // Deinterleave + decodeDeInterleave(); + + // Error check + decodeErrorCheck(); + + // Extract Data + decodeExtractData(out); +} + +// The main encode function +void CBPTC19696::encode(const unsigned char* in, unsigned char* out) +{ + assert(in != NULL); + assert(out != NULL); + + // Extract Data + encodeExtractData(in); + + // Error check + encodeErrorCheck(); + + // Deinterleave + encodeInterleave(); + + // Get the raw binary + encodeExtractBinary(out); +} + +void CBPTC19696::decodeExtractBinary(const unsigned char* in) +{ + // First block + CUtils::byteToBitsBE(in[0U], m_rawData + 0U); + CUtils::byteToBitsBE(in[1U], m_rawData + 8U); + CUtils::byteToBitsBE(in[2U], m_rawData + 16U); + CUtils::byteToBitsBE(in[3U], m_rawData + 24U); + CUtils::byteToBitsBE(in[4U], m_rawData + 32U); + CUtils::byteToBitsBE(in[5U], m_rawData + 40U); + CUtils::byteToBitsBE(in[6U], m_rawData + 48U); + CUtils::byteToBitsBE(in[7U], m_rawData + 56U); + CUtils::byteToBitsBE(in[8U], m_rawData + 64U); + CUtils::byteToBitsBE(in[9U], m_rawData + 72U); + CUtils::byteToBitsBE(in[10U], m_rawData + 80U); + CUtils::byteToBitsBE(in[11U], m_rawData + 88U); + CUtils::byteToBitsBE(in[12U], m_rawData + 96U); + + // Handle the two bits + bool bits[8U]; + CUtils::byteToBitsBE(in[20U], bits); + m_rawData[98U] = bits[6U]; + m_rawData[99U] = bits[7U]; + + // Second block + CUtils::byteToBitsBE(in[21U], m_rawData + 100U); + CUtils::byteToBitsBE(in[22U], m_rawData + 108U); + CUtils::byteToBitsBE(in[23U], m_rawData + 116U); + CUtils::byteToBitsBE(in[24U], m_rawData + 124U); + CUtils::byteToBitsBE(in[25U], m_rawData + 132U); + CUtils::byteToBitsBE(in[26U], m_rawData + 140U); + CUtils::byteToBitsBE(in[27U], m_rawData + 148U); + CUtils::byteToBitsBE(in[28U], m_rawData + 156U); + CUtils::byteToBitsBE(in[29U], m_rawData + 164U); + CUtils::byteToBitsBE(in[30U], m_rawData + 172U); + CUtils::byteToBitsBE(in[31U], m_rawData + 180U); + CUtils::byteToBitsBE(in[32U], m_rawData + 188U); +} + +// Deinterleave the raw data +void CBPTC19696::decodeDeInterleave() +{ + for (unsigned int i = 0U; i < 196U; i++) + m_deInterData[i] = false; + + // The first bit is R(3) which is not used so can be ignored + for (unsigned int a = 0U; a < 196U; a++) { + // Calculate the interleave sequence + unsigned int interleaveSequence = (a * 181U) % 196U; + // Shuffle the data + m_deInterData[a] = m_rawData[interleaveSequence]; + } +} + +// Check each row with a Hamming (15,11,3) code and each column with a Hamming (13,9,3) code +void CBPTC19696::decodeErrorCheck() +{ + bool fixing; + unsigned int count = 0U; + do { + fixing = false; + + // Run through each of the 15 columns + bool col[13U]; + for (unsigned int c = 0U; c < 15U; c++) { + unsigned int pos = c + 1U; + for (unsigned int a = 0U; a < 13U; a++) { + col[a] = m_deInterData[pos]; + pos = pos + 15U; + } + + if (CHamming::decode1393(col)) { + unsigned int pos = c + 1U; + for (unsigned int a = 0U; a < 13U; a++) { + m_deInterData[pos] = col[a]; + pos = pos + 15U; + } + + fixing = true; + } + } + + // Run through each of the 9 rows containing data + for (unsigned int r = 0U; r < 9U; r++) { + unsigned int pos = (r * 15U) + 1U; + if (CHamming::decode15113(m_deInterData + pos)) + fixing = true; + } + + count++; + } while (fixing && count < 5U); +} + +// Extract the 96 bits of payload +void CBPTC19696::decodeExtractData(unsigned char* data) const +{ + bool bData[96U]; + unsigned int pos = 0U; + for (unsigned int a = 4U; a <= 11U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 16U; a <= 26U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 31U; a <= 41U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 46U; a <= 56U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 61U; a <= 71U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 76U; a <= 86U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 91U; a <= 101U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 106U; a <= 116U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 121U; a <= 131U; a++, pos++) + bData[pos] = m_deInterData[a]; + + CUtils::bitsToByteBE(bData + 0U, data[0U]); + CUtils::bitsToByteBE(bData + 8U, data[1U]); + CUtils::bitsToByteBE(bData + 16U, data[2U]); + CUtils::bitsToByteBE(bData + 24U, data[3U]); + CUtils::bitsToByteBE(bData + 32U, data[4U]); + CUtils::bitsToByteBE(bData + 40U, data[5U]); + CUtils::bitsToByteBE(bData + 48U, data[6U]); + CUtils::bitsToByteBE(bData + 56U, data[7U]); + CUtils::bitsToByteBE(bData + 64U, data[8U]); + CUtils::bitsToByteBE(bData + 72U, data[9U]); + CUtils::bitsToByteBE(bData + 80U, data[10U]); + CUtils::bitsToByteBE(bData + 88U, data[11U]); +} + +// Extract the 96 bits of payload +void CBPTC19696::encodeExtractData(const unsigned char* in) const +{ + bool bData[96U]; + CUtils::byteToBitsBE(in[0U], bData + 0U); + CUtils::byteToBitsBE(in[1U], bData + 8U); + CUtils::byteToBitsBE(in[2U], bData + 16U); + CUtils::byteToBitsBE(in[3U], bData + 24U); + CUtils::byteToBitsBE(in[4U], bData + 32U); + CUtils::byteToBitsBE(in[5U], bData + 40U); + CUtils::byteToBitsBE(in[6U], bData + 48U); + CUtils::byteToBitsBE(in[7U], bData + 56U); + CUtils::byteToBitsBE(in[8U], bData + 64U); + CUtils::byteToBitsBE(in[9U], bData + 72U); + CUtils::byteToBitsBE(in[10U], bData + 80U); + CUtils::byteToBitsBE(in[11U], bData + 88U); + + for (unsigned int i = 0U; i < 196U; i++) + m_deInterData[i] = false; + + unsigned int pos = 0U; + for (unsigned int a = 4U; a <= 11U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 16U; a <= 26U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 31U; a <= 41U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 46U; a <= 56U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 61U; a <= 71U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 76U; a <= 86U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 91U; a <= 101U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 106U; a <= 116U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 121U; a <= 131U; a++, pos++) + m_deInterData[a] = bData[pos]; +} + +// Check each row with a Hamming (15,11,3) code and each column with a Hamming (13,9,3) code +void CBPTC19696::encodeErrorCheck() +{ + // Run through each of the 15 columns + bool col[13U]; + for (unsigned int c = 0U; c < 15U; c++) { + unsigned int pos = c + 1U; + for (unsigned int a = 0U; a < 13U; a++) { + col[a] = m_deInterData[pos]; + pos = pos + 15U; + } + + CHamming::encode1393(col); + + pos = c + 1U; + for (unsigned int a = 0U; a < 13U; a++) { + m_deInterData[pos] = col[a]; + pos = pos + 15U; + } + } + + // Run through each of the 9 rows containing data + for (unsigned int r = 0U; r < 9U; r++) { + unsigned int pos = (r * 15U) + 1U; + CHamming::encode15113(m_deInterData + pos); + } +} + +// Interleave the raw data +void CBPTC19696::encodeInterleave() +{ + for (unsigned int i = 0U; i < 196U; i++) + m_rawData[i] = false; + + // The first bit is R(3) which is not used so can be ignored + for (unsigned int a = 0U; a < 196U; a++) { + // Calculate the interleave sequence + unsigned int interleaveSequence = (a * 181U) % 196U; + // Unshuffle the data + m_rawData[interleaveSequence] = m_deInterData[a]; + } +} + +void CBPTC19696::encodeExtractBinary(unsigned char* data) +{ + // First block + CUtils::bitsToByteBE(m_rawData + 0U, data[0U]); + CUtils::bitsToByteBE(m_rawData + 8U, data[1U]); + CUtils::bitsToByteBE(m_rawData + 16U, data[2U]); + CUtils::bitsToByteBE(m_rawData + 24U, data[3U]); + CUtils::bitsToByteBE(m_rawData + 32U, data[4U]); + CUtils::bitsToByteBE(m_rawData + 40U, data[5U]); + CUtils::bitsToByteBE(m_rawData + 48U, data[6U]); + CUtils::bitsToByteBE(m_rawData + 56U, data[7U]); + CUtils::bitsToByteBE(m_rawData + 64U, data[8U]); + CUtils::bitsToByteBE(m_rawData + 72U, data[9U]); + CUtils::bitsToByteBE(m_rawData + 80U, data[10U]); + CUtils::bitsToByteBE(m_rawData + 88U, data[11U]); + + // Handle the two bits + unsigned char byte; + CUtils::bitsToByteBE(m_rawData + 96U, byte); + data[12U] = (data[12U] & 0x3FU) | ((byte >> 0) & 0xC0U); + data[13U] = (data[13U] & 0xFCU) | ((byte >> 4) & 0x03U); + +// Second block + CUtils::bitsToByteBE(m_rawData + 100U, data[21U]); + CUtils::bitsToByteBE(m_rawData + 108U, data[22U]); + CUtils::bitsToByteBE(m_rawData + 116U, data[23U]); + CUtils::bitsToByteBE(m_rawData + 124U, data[24U]); + CUtils::bitsToByteBE(m_rawData + 132U, data[25U]); + CUtils::bitsToByteBE(m_rawData + 140U, data[26U]); + CUtils::bitsToByteBE(m_rawData + 148U, data[27U]); + CUtils::bitsToByteBE(m_rawData + 156U, data[28U]); + CUtils::bitsToByteBE(m_rawData + 164U, data[29U]); + CUtils::bitsToByteBE(m_rawData + 172U, data[30U]); + CUtils::bitsToByteBE(m_rawData + 180U, data[31U]); + CUtils::bitsToByteBE(m_rawData + 188U, data[32U]); +} diff --git a/BPTC19696.h b/BPTC19696.h new file mode 100644 index 0000000..0a40a78 --- /dev/null +++ b/BPTC19696.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(BPTC19696_H) +#define BPTC19696_H + +class CBPTC19696 +{ +public: + CBPTC19696(); + ~CBPTC19696(); + + void decode(const unsigned char* in, unsigned char* out); + + void encode(const unsigned char* in, unsigned char* out); + +private: + bool* m_rawData; + bool* m_deInterData; + + void decodeExtractBinary(const unsigned char* in); + void decodeErrorCheck(); + void decodeDeInterleave(); + void decodeExtractData(unsigned char* data) const; + + void encodeExtractData(const unsigned char* in) const; + void encodeInterleave(); + void encodeErrorCheck(); + void encodeExtractBinary(unsigned char* data); +}; + +#endif diff --git a/CRC.cpp b/CRC.cpp new file mode 100644 index 0000000..b118f20 --- /dev/null +++ b/CRC.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "CRC.h" + +#include "Utils.h" + +#include +#include +#include + +bool CCRC::checkFiveBit(bool* in, unsigned int tcrc) +{ + assert(in != NULL); + + unsigned int crc; + encodeFiveBit(in, crc); + + return crc == tcrc; +} + +void CCRC::encodeFiveBit(const bool* in, unsigned int& tcrc) +{ + assert(in != NULL); + + unsigned short total = 0U; + for (unsigned int i = 0U; i < 72U; i += 8U) { + unsigned char c; + CUtils::bitsToByteBE(in + i, c); + total += c; + } + + total %= 31U; + + tcrc = total; +} + +unsigned char CCRC::encodeEightBit(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + + unsigned char crc = 0x00U; + + for (unsigned int i = 0U; i < length; i++) { + crc ^= in[i]; + + for (unsigned int j = 0U; j < 8U; j++) { + if ((crc & 0x80U) == 0x80U) { + crc <<= 1; + crc ^= 0x07U; + } else { + crc <<= 1; + } + } + } + + return crc; +} + +bool CCRC::checkCSBK(const unsigned char *in) +{ + unsigned short crc16 = 0U; + + // Run through all 12 bits + for (unsigned int a = 0; a < 12U; a++) { + unsigned char val = in[a]; + + // Allow for the CSBK CRC mask + if (a > 9U) + val ^= 0xA5U; + + for (unsigned int i = 0U; i < 8U; i++) { + bool c15 = (crc16 >> 15 & 0x01U) == 0x01U; + bool bit = (val >> (7 - i) & 0x01U) == 0x01U; + crc16 <<= 1; + if (c15 ^ bit) + crc16 ^= 0x1021U; + } + } + + return crc16 == 0x1D0FU; +} + +unsigned char CCRC::crc8(const unsigned char *in, unsigned int length) +{ + unsigned int crc = 0U; + + for (unsigned int j = 0U; j < length; j++, in++) { + crc ^= (*in << 8); + + for (unsigned int i = 0U; i < 8U; i++) { + if (crc & 0x8000U) + crc ^= (0x1070U << 3); + crc <<= 1; + } + } + + return crc >> 8; +} diff --git a/CRC.h b/CRC.h new file mode 100644 index 0000000..bbbc5b5 --- /dev/null +++ b/CRC.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(CRC_H) +#define CRC_H + +class CCRC +{ +public: + static bool checkFiveBit(bool* in, unsigned int tcrc); + static void encodeFiveBit(const bool* in, unsigned int& tcrc); + + static bool checkCSBK(const unsigned char* in); + + static unsigned char encodeEightBit(const unsigned char* in, unsigned int length); + + static unsigned char crc8(const unsigned char* in, unsigned int length); +}; + +#endif diff --git a/CSBK.cpp b/CSBK.cpp new file mode 100644 index 0000000..e285af2 --- /dev/null +++ b/CSBK.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "CSBK.h" +#include "BPTC19696.h" +#include "CRC.h" +#include "Log.h" // XXXX + +#include "Utils.h" + +#include +#include + +CCSBK::CCSBK(const unsigned char* bytes) : +m_CSBKO(CSBKO_NONE), +m_FID(0x00U), +m_bsId(0U), +m_srcId(0U), +m_valid(false) +{ + assert(bytes != NULL); + + CBPTC19696 bptc; + + unsigned char data[12U]; + bptc.decode(bytes, data); + + m_valid = CCRC::checkCSBK(data); + + m_CSBKO = CSBKO(data[0U] & 0x3FU); + m_FID = data[1U]; + + if (m_CSBKO == CSBKO_BSDWNACT) { + m_bsId = data[4U] << 16 | data[5U] << 8 | data[6U]; + m_srcId = data[7U] << 16 | data[8U] << 8 | data[9U]; + CUtils::dump("Download activate CSBK", data, 12U); + } else { + CUtils::dump("Unhandled CSBK type", data, 12U); + } +} + +CCSBK::~CCSBK() +{ +} + +bool CCSBK::isValid() const +{ + return m_valid; +} + +CSBKO CCSBK::getCSBKO() const +{ + return m_CSBKO; +} + +unsigned char CCSBK::getFID() const +{ + return m_FID; +} + +unsigned int CCSBK::getBSId() const +{ + return m_bsId; +} + +unsigned int CCSBK::getSrcId() const +{ + return m_srcId; +} diff --git a/CSBK.h b/CSBK.h new file mode 100644 index 0000000..91b6973 --- /dev/null +++ b/CSBK.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(CSBK_H) +#define CSBK_H + +#include "DMRDefines.h" + +enum CSBKO { + CSBKO_NONE = 0x00, + CSBKO_UUVREQ = 0x04, + CSBKO_UUANSRSP = 0x05, + CSBKO_CTCSBK = 0x07, + CSBKO_NACKRSP = 0x26, + CSBKO_BSDWNACT = 0x38, + CSBKO_PRECCSBK = 0x3D +}; + +class CCSBK +{ +public: + CCSBK(const unsigned char* bytes); + ~CCSBK(); + + bool isValid() const; + + // Generic fields + CSBKO getCSBKO() const; + unsigned char getFID() const; + + // For BS Dwn Act + unsigned int getBSId() const; + unsigned int getSrcId() const; + +private: + CSBKO m_CSBKO; + unsigned char m_FID; + unsigned int m_bsId; + unsigned int m_srcId; + bool m_valid; +}; + +#endif diff --git a/Conf.cpp b/Conf.cpp new file mode 100644 index 0000000..9eb3112 --- /dev/null +++ b/Conf.cpp @@ -0,0 +1,494 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "Conf.h" +#include "Log.h" + +#include +#include +#include + +const int BUFFER_SIZE = 500; + +enum SECTION { + SECTION_NONE, + SECTION_GENERAL, + SECTION_INFO, + SECTION_LOG, + SECTION_MODEM, + SECTION_DSTAR, + SECTION_DMR, + SECTION_FUSION, + SECTION_DSTAR_NETWORK, + SECTION_DMR_NETWORK, + SECTION_FUSION_NETWORK, + SECTION_TFTSERIAL +}; + +CConf::CConf(const std::string& file) : +m_file(file), +m_callsign(), +m_timeout(120U), +m_duplex(true), +m_modeHang(10U), +m_display(), +m_rxFrequency(0U), +m_txFrequency(0U), +m_power(0U), +m_latitude(0.0F), +m_longitude(0.0F), +m_height(0), +m_location(), +m_description(), +m_url(), +m_logLevel(0U), +m_logPath(), +m_logRoot(), +m_logDisplay(true), +m_modemPort(), +m_modemRXInvert(false), +m_modemTXInvert(false), +m_modemPTTInvert(false), +m_modemTXDelay(100U), +m_modemRXLevel(100U), +m_modemTXLevel(100U), +m_modemDebug(false), +m_dstarEnabled(true), +m_dstarModule("C"), +m_dmrEnabled(true), +m_dmrId(0U), +m_dmrColorCode(2U), +m_fusionEnabled(true), +m_dstarNetworkEnabled(true), +m_dstarGatewayAddress(), +m_dstarGatewayPort(0U), +m_dstarLocalPort(0U), +m_dstarNetworkDebug(false), +m_dmrNetworkEnabled(true), +m_dmrNetworkAddress(), +m_dmrNetworkPort(0U), +m_dmrNetworkPassword(), +m_dmrNetworkDebug(false), +m_fusionNetworkEnabled(false), +m_fusionNetworkAddress(), +m_fusionNetworkPort(0U), +m_fusionNetworkDebug(false), +m_tftSerialPort() +{ +} + +CConf::~CConf() +{ +} + +bool CConf::read() +{ + FILE* fp = ::fopen(m_file.c_str(), "rt"); + if (fp == NULL) { + ::fprintf(stderr, "Couldn't open the .ini file - %s\n", m_file.c_str()); + return false; + } + + SECTION section = SECTION_NONE; + + char buffer[BUFFER_SIZE]; + while (::fgets(buffer, BUFFER_SIZE, fp) != NULL) { + if (buffer[0U] == '#') + continue; + + if (buffer[0U] == '[') { + if (::strncmp(buffer, "[General]", 9U) == 0) + section = SECTION_GENERAL; + else if (::strncmp(buffer, "[Info]", 6U) == 0) + section = SECTION_INFO; + else if (::strncmp(buffer, "[Log]", 5U) == 0) + section = SECTION_LOG; + else if (::strncmp(buffer, "[Modem]", 7U) == 0) + section = SECTION_MODEM; + else if (::strncmp(buffer, "[D-Star]", 8U) == 0) + section = SECTION_DSTAR; + else if (::strncmp(buffer, "[DMR]", 5U) == 0) + section = SECTION_DMR; + else if (::strncmp(buffer, "[System Fusion]", 15U) == 0) + section = SECTION_FUSION; + else if (::strncmp(buffer, "[D-Star Network]", 16U) == 0) + section = SECTION_DSTAR_NETWORK; + else if (::strncmp(buffer, "[DMR Network]", 13U) == 0) + section = SECTION_DMR_NETWORK; + else if (::strncmp(buffer, "[System Fusion Network]", 23U) == 0) + section = SECTION_FUSION_NETWORK; + else if (::strncmp(buffer, "[TFT Serial]", 11U) == 0) + section = SECTION_TFTSERIAL; + else + section = SECTION_NONE; + + continue; + } + + char* key = ::strtok(buffer, " \t=\r\n"); + if (key == NULL) + continue; + + char* value = ::strtok(NULL, "\r\n"); + if (section == SECTION_GENERAL) { + if (::strcmp(key, "Callsign") == 0) + m_callsign = value; + else if (::strcmp(key, "Timeout") == 0) + m_timeout = (unsigned int)::atoi(value); + else if (::strcmp(key, "Duplex") == 0) + m_duplex = ::atoi(value) == 1; + else if (::strcmp(key, "ModeHang") == 0) + m_modeHang = (unsigned int)::atoi(value); + else if (::strcmp(key, "Display") == 0) + m_display = value; + } else if (section == SECTION_INFO) { + if (::strcmp(key, "TXFrequency") == 0) + m_txFrequency = (unsigned int)::atoi(value); + else if (::strcmp(key, "RXFrequency") == 0) + m_rxFrequency = (unsigned int)::atoi(value); + else if (::strcmp(key, "Power") == 0) + m_power = (unsigned int)::atoi(value); + else if (::strcmp(key, "Latitude") == 0) + m_latitude = float(::atof(value)); + else if (::strcmp(key, "Longitude") == 0) + m_longitude = float(::atof(value)); + else if (::strcmp(key, "Height") == 0) + m_height = ::atoi(value); + else if (::strcmp(key, "Location") == 0) + m_location = value; + else if (::strcmp(key, "Description") == 0) + m_description = value; + else if (::strcmp(key, "URL") == 0) + m_url = value; + } else if (section == SECTION_LOG) { + if (::strcmp(key, "Path") == 0) + m_logPath = value; + else if (::strcmp(key, "Root") == 0) + m_logRoot = value; + else if (::strcmp(key, "Level") == 0) + m_logLevel = (unsigned int)::atoi(value); + else if (::strcmp(key, "Display") == 0) + m_logDisplay = ::atoi(value) == 1; + } else if (section == SECTION_MODEM) { + if (::strcmp(key, "Port") == 0) + m_modemPort = value; + else if (::strcmp(key, "RXInvert") == 0) + m_modemRXInvert = ::atoi(value) == 1; + else if (::strcmp(key, "TXInvert") == 0) + m_modemTXInvert = ::atoi(value) == 1; + else if (::strcmp(key, "PTTInvert") == 0) + m_modemPTTInvert = ::atoi(value) == 1; + else if (::strcmp(key, "TXDelay") == 0) + m_modemTXDelay = (unsigned int)::atoi(value); + else if (::strcmp(key, "RXLevel") == 0) + m_modemRXLevel = (unsigned int)::atoi(value); + else if (::strcmp(key, "TXLevel") == 0) + m_modemTXLevel = (unsigned int)::atoi(value); + else if (::strcmp(key, "Debug") == 0) + m_modemDebug = ::atoi(value) == 1; + } else if (section == SECTION_DSTAR) { + if (::strcmp(key, "Enabled") == 0) + m_dstarEnabled = ::atoi(value) == 1; + else if (::strcmp(key, "Module") == 0) + m_dstarModule = value; + } else if (section == SECTION_DMR) { + if (::strcmp(key, "Enabled") == 0) + m_dmrEnabled = ::atoi(value) == 1; + else if (::strcmp(key, "Id") == 0) + m_dmrId = (unsigned int)::atoi(value); + else if (::strcmp(key, "ColorCode") == 0) + m_dmrColorCode = (unsigned int)::atoi(value); + } else if (section == SECTION_FUSION) { + if (::strcmp(key, "Enabled") == 0) + m_fusionEnabled = ::atoi(value) == 1; + } else if (section == SECTION_DSTAR_NETWORK) { + if (::strcmp(key, "Enabled") == 0) + m_dstarNetworkEnabled = ::atoi(value) == 1; + else if (::strcmp(key, "GatewayAddress") == 0) + m_dstarGatewayAddress = value; + else if (::strcmp(key, "GatewayPort") == 0) + m_dstarGatewayPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "LocalPort") == 0) + m_dstarLocalPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "Debug") == 0) + m_dstarNetworkDebug = ::atoi(value) == 1; + } else if (section == SECTION_DMR_NETWORK) { + if (::strcmp(key, "Enabled") == 0) + m_dmrNetworkEnabled = ::atoi(value) == 1; + else if (::strcmp(key, "Address") == 0) + m_dmrNetworkAddress = value; + else if (::strcmp(key, "Port") == 0) + m_dmrNetworkPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "Password") == 0) + m_dmrNetworkPassword = value; + else if (::strcmp(key, "Debug") == 0) + m_dmrNetworkDebug = ::atoi(value) == 1; + } else if (section == SECTION_FUSION_NETWORK) { + if (::strcmp(key, "Enabled") == 0) + m_fusionNetworkEnabled = ::atoi(value) == 1; + else if (::strcmp(key, "Address") == 0) + m_fusionNetworkAddress = value; + else if (::strcmp(key, "Port") == 0) + m_fusionNetworkPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "Debug") == 0) + m_fusionNetworkDebug = ::atoi(value) == 1; + } else if (section == SECTION_TFTSERIAL) { + if (::strcmp(key, "Port") == 0) + m_tftSerialPort = value; + } + } + + ::fclose(fp); + + return true; +} + +std::string CConf::getCallsign() const +{ + return m_callsign; +} + +unsigned int CConf::getTimeout() const +{ + return m_timeout; +} + +bool CConf::getDuplex() const +{ + return m_duplex; +} + +unsigned int CConf::getModeHang() const +{ + return m_modeHang; +} + +std::string CConf::getDisplay() const +{ + return m_display; +} + +unsigned int CConf::getRxFrequency() const +{ + return m_rxFrequency; +} + +unsigned int CConf::getTxFrequency() const +{ + return m_txFrequency; +} + +unsigned int CConf::getPower() const +{ + return m_power; +} + +float CConf::getLatitude() const +{ + return m_latitude; +} + +float CConf::getLongitude() const +{ + return m_longitude; +} + +int CConf::getHeight() const +{ + return m_height; +} + +std::string CConf::getLocation() const +{ + return m_location; +} + +std::string CConf::getDescription() const +{ + return m_description; +} + +std::string CConf::getURL() const +{ + return m_url; +} + +unsigned int CConf::getLogLevel() const +{ + return m_logLevel; +} + +std::string CConf::getLogPath() const +{ + return m_logPath; +} + +std::string CConf::getLogRoot() const +{ + return m_logRoot; +} + +bool CConf::getLogDisplay() const +{ + return m_logDisplay; +} + +std::string CConf::getModemPort() const +{ + return m_modemPort; +} + +bool CConf::getModemRXInvert() const +{ + return m_modemRXInvert; +} + +bool CConf::getModemTXInvert() const +{ + return m_modemTXInvert; +} + +bool CConf::getModemPTTInvert() const +{ + return m_modemPTTInvert; +} + +unsigned int CConf::getModemTXDelay() const +{ + return m_modemTXDelay; +} + +unsigned int CConf::getModemRXLevel() const +{ + return m_modemRXLevel; +} + +unsigned int CConf::getModemTXLevel() const +{ + return m_modemTXLevel; +} + +bool CConf::getModemDebug() const +{ + return m_modemDebug; +} + +bool CConf::getDStarEnabled() const +{ + return m_dstarEnabled; +} + +std::string CConf::getDStarModule() const +{ + return m_dstarModule; +} + +bool CConf::getDMREnabled() const +{ + return m_dmrEnabled; +} + +unsigned int CConf::getDMRId() const +{ + return m_dmrId; +} + +unsigned int CConf::getDMRColorCode() const +{ + return m_dmrColorCode; +} + +bool CConf::getFusionEnabled() const +{ + return m_fusionEnabled; +} + +bool CConf::getDStarNetworkEnabled() const +{ + return m_dstarNetworkEnabled; +} + +std::string CConf::getDStarGatewayAddress() const +{ + return m_dstarGatewayAddress; +} + +unsigned int CConf::getDStarGatewayPort() const +{ + return m_dstarGatewayPort; +} + +unsigned int CConf::getDStarLocalPort() const +{ + return m_dstarLocalPort; +} + +bool CConf::getDStarNetworkDebug() const +{ + return m_dstarNetworkDebug; +} + +bool CConf::getDMRNetworkEnabled() const +{ + return m_dmrNetworkEnabled; +} + +std::string CConf::getDMRNetworkAddress() const +{ + return m_dmrNetworkAddress; +} + +unsigned int CConf::getDMRNetworkPort() const +{ + return m_dmrNetworkPort; +} + +std::string CConf::getDMRNetworkPassword() const +{ + return m_dmrNetworkPassword; +} + +bool CConf::getDMRNetworkDebug() const +{ + return m_dmrNetworkDebug; +} + +bool CConf::getFusionNetworkEnabled() const +{ + return m_fusionNetworkEnabled; +} + +std::string CConf::getFusionNetworkAddress() const +{ + return m_fusionNetworkAddress; +} + +unsigned int CConf::getFusionNetworkPort() const +{ + return m_fusionNetworkPort; +} + +bool CConf::getFusionNetworkDebug() const +{ + return m_fusionNetworkDebug; +} + +std::string CConf::getTFTSerialPort() const +{ + return m_tftSerialPort; +} diff --git a/Conf.h b/Conf.h new file mode 100644 index 0000000..d81f189 --- /dev/null +++ b/Conf.h @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(CONF_H) +#define CONF_H + +#include + +class CConf +{ +public: + CConf(const std::string& file); + ~CConf(); + + bool read(); + + // The General section + std::string getCallsign() const; + unsigned int getTimeout() const; + bool getDuplex() const; + unsigned int getModeHang() const; + std::string getDisplay() const; + + // The Info section + unsigned int getRxFrequency() const; + unsigned int getTxFrequency() const; + unsigned int getPower() const; + float getLatitude() const; + float getLongitude() const; + int getHeight() const; + std::string getLocation() const; + std::string getDescription() const; + std::string getURL() const; + + // The Log section + std::string getLogPath() const; + std::string getLogRoot() const; + unsigned int getLogLevel() const; + bool getLogDisplay() const; + + // The Modem section + std::string getModemPort() const; + bool getModemRXInvert() const; + bool getModemTXInvert() const; + bool getModemPTTInvert() const; + unsigned int getModemTXDelay() const; + unsigned int getModemRXLevel() const; + unsigned int getModemTXLevel() const; + bool getModemDebug() const; + + // The D-Star section + bool getDStarEnabled() const; + std::string getDStarModule() const; + + // The DMR section + bool getDMREnabled() const; + unsigned int getDMRId() const; + unsigned int getDMRColorCode() const; + + // The System Fusion section + bool getFusionEnabled() const; + + // The D-Star Network section + bool getDStarNetworkEnabled() const; + std::string getDStarGatewayAddress() const; + unsigned int getDStarGatewayPort() const; + unsigned int getDStarLocalPort() const; + bool getDStarNetworkDebug() const; + + // The DMR Network section + bool getDMRNetworkEnabled() const; + std::string getDMRNetworkAddress() const; + unsigned int getDMRNetworkPort() const; + std::string getDMRNetworkPassword() const; + bool getDMRNetworkDebug() const; + + // The System Fusion Network section + bool getFusionNetworkEnabled() const; + std::string getFusionNetworkAddress() const; + unsigned int getFusionNetworkPort() const; + bool getFusionNetworkDebug() const; + + // The TFTSERIAL section + std::string getTFTSerialPort() const; + +private: + std::string m_file; + std::string m_callsign; + unsigned int m_timeout; + bool m_duplex; + unsigned int m_modeHang; + std::string m_display; + + unsigned int m_rxFrequency; + unsigned int m_txFrequency; + unsigned int m_power; + float m_latitude; + float m_longitude; + int m_height; + std::string m_location; + std::string m_description; + std::string m_url; + + unsigned int m_logLevel; + std::string m_logPath; + std::string m_logRoot; + bool m_logDisplay; + + std::string m_modemPort; + bool m_modemRXInvert; + bool m_modemTXInvert; + bool m_modemPTTInvert; + unsigned int m_modemTXDelay; + unsigned int m_modemRXLevel; + unsigned int m_modemTXLevel; + bool m_modemDebug; + + bool m_dstarEnabled; + std::string m_dstarModule; + + bool m_dmrEnabled; + unsigned int m_dmrId; + unsigned int m_dmrColorCode; + + bool m_fusionEnabled; + + bool m_dstarNetworkEnabled; + std::string m_dstarGatewayAddress; + unsigned int m_dstarGatewayPort; + unsigned int m_dstarLocalPort; + bool m_dstarNetworkDebug; + + bool m_dmrNetworkEnabled; + std::string m_dmrNetworkAddress; + unsigned int m_dmrNetworkPort; + std::string m_dmrNetworkPassword; + bool m_dmrNetworkDebug; + + bool m_fusionNetworkEnabled; + unsigned int m_fusionNetworkPort; + std::string m_fusionNetworkAddress; + bool m_fusionNetworkDebug; + + std::string m_tftSerialPort; +}; + +#endif diff --git a/DMRControl.cpp b/DMRControl.cpp new file mode 100644 index 0000000..52e8058 --- /dev/null +++ b/DMRControl.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2015,2016 Jonathan Naylor, G4KLX + * + * 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; version 2 of the License. + * + * 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. + */ + +#include "DMRControl.h" +#include "Defines.h" +#include "CSBK.h" +#include "Log.h" + +#include + +CDMRControl::CDMRControl(unsigned int id, unsigned int colorCode, unsigned int timeout, CModem* modem, CHomebrewDMRIPSC* network, IDisplay* display) : +m_id(id), +m_colorCode(colorCode), +m_modem(modem), +m_network(network), +m_slot1(1U, timeout), +m_slot2(2U, timeout) +{ + assert(modem != NULL); + assert(display != NULL); + + CDMRSlot::init(colorCode, modem, network, display); +} + +CDMRControl::~CDMRControl() +{ +} + +bool CDMRControl::processWakeup(const unsigned char* data) +{ + // Wakeups always come in on slot 1 + if (data[0U] != TAG_DATA || data[1U] != (DMR_IDLE_RX | DMR_SYNC_DATA | DT_CSBK)) + return false; + + CCSBK csbk(data + 2U); + + CSBKO csbko = csbk.getCSBKO(); + if (csbko != CSBKO_BSDWNACT) + return false; + + unsigned int bsId = csbk.getBSId(); + if (bsId == 0xFFFFFFU) { + LogMessage("CSBK BS_Dwn_Act for any received from %u", csbk.getSrcId()); + return true; + } else if (bsId == m_id) { + LogMessage("CSBK BS_Dwn_Act for %u received from %u", bsId, csbk.getSrcId()); + return true; + } + + return false; +} + +void CDMRControl::writeModemSlot1(unsigned char *data) +{ + m_slot1.writeModem(data); +} + +void CDMRControl::writeModemSlot2(unsigned char *data) +{ + m_slot2.writeModem(data); +} + +unsigned int CDMRControl::readModemSlot1(unsigned char *data) +{ + return m_slot1.readModem(data); +} + +unsigned int CDMRControl::readModemSlot2(unsigned char *data) +{ + return m_slot2.readModem(data); +} + +void CDMRControl::clock(unsigned int ms) +{ + if (m_network != NULL) { + CDMRData data; + bool ret = m_network->read(data); + if (ret) { + unsigned int slotNo = data.getSlotNo(); + switch (slotNo) { + case 1U: m_slot1.writeNetwork(data); break; + case 2U: m_slot2.writeNetwork(data); break; + default: LogError("Invalid slot no %u", slotNo); break; + } + } + + m_network->clock(ms); + } + + m_slot1.clock(ms); + m_slot2.clock(ms); +} diff --git a/DMRControl.h b/DMRControl.h new file mode 100644 index 0000000..bc33e69 --- /dev/null +++ b/DMRControl.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DMRControl_H) +#define DMRControl_H + +#include "HomebrewDMRIPSC.h" +#include "Display.h" +#include "DMRSlot.h" +#include "DMRData.h" +#include "Modem.h" + + +class CDMRControl { +public: + CDMRControl(unsigned int id, unsigned int colorCode, unsigned int timeout, CModem* modem, CHomebrewDMRIPSC* network, IDisplay* display); + ~CDMRControl(); + + bool processWakeup(const unsigned char* data); + + void writeModemSlot1(unsigned char* data); + void writeModemSlot2(unsigned char* data); + + unsigned int readModemSlot1(unsigned char* data); + unsigned int readModemSlot2(unsigned char* data); + + void clock(unsigned int ms); + +private: + unsigned int m_id; + unsigned int m_colorCode; + CModem* m_modem; + CHomebrewDMRIPSC* m_network; + CDMRSlot m_slot1; + CDMRSlot m_slot2; +}; + +#endif diff --git a/DMRData.cpp b/DMRData.cpp new file mode 100644 index 0000000..3952ce4 --- /dev/null +++ b/DMRData.cpp @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2015 Jonathan Naylor, G4KLX + * + * 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; version 2 of the License. + * + * 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. + */ + +#include "DMRData.h" +#include "DMRDefines.h" +#include "Utils.h" +#include "Log.h" + +#include +#include +#include + + +CDMRData::CDMRData(const CDMRData& data) : +m_slotNo(data.m_slotNo), +m_data(NULL), +m_srcId(data.m_srcId), +m_dstId(data.m_dstId), +m_flco(data.m_flco), +m_dataType(data.m_dataType), +m_seqNo(data.m_seqNo), +m_n(data.m_n) +{ + m_data = new unsigned char[2U * DMR_FRAME_LENGTH_BYTES]; + ::memcpy(m_data, data.m_data, 2U * DMR_FRAME_LENGTH_BYTES); +} + +CDMRData::CDMRData() : +m_slotNo(1U), +m_data(NULL), +m_srcId(0U), +m_dstId(0U), +m_flco(FLCO_GROUP), +m_dataType(0U), +m_seqNo(0U), +m_n(0U) +{ + m_data = new unsigned char[2U * DMR_FRAME_LENGTH_BYTES]; +} + +CDMRData::~CDMRData() +{ + delete[] m_data; +} + +CDMRData& CDMRData::operator=(const CDMRData& data) +{ + if (this != &data) { + ::memcpy(m_data, data.m_data, DMR_FRAME_LENGTH_BYTES); + + m_slotNo = data.m_slotNo; + m_srcId = data.m_srcId; + m_dstId = data.m_dstId; + m_flco = data.m_flco; + m_dataType = data.m_dataType; + m_seqNo = data.m_seqNo; + m_n = data.m_n; + } + + return *this; +} + +unsigned int CDMRData::getSlotNo() const +{ + return m_slotNo; +} + +void CDMRData::setSlotNo(unsigned int slotNo) +{ + assert(slotNo == 1U || slotNo == 2U); + + m_slotNo = slotNo; +} + +unsigned char CDMRData::getDataType() const +{ + return m_dataType; +} + +void CDMRData::setDataType(unsigned char dataType) +{ + m_dataType = dataType; +} + +unsigned int CDMRData::getSrcId() const +{ + return m_srcId; +} + +void CDMRData::setSrcId(unsigned int id) +{ + m_srcId = id; +} + +unsigned int CDMRData::getDstId() const +{ + return m_dstId; +} + +void CDMRData::setDstId(unsigned int id) +{ + m_dstId = id; +} + +FLCO CDMRData::getFLCO() const +{ + return m_flco; +} + +void CDMRData::setFLCO(FLCO flco) +{ + m_flco = flco; +} + +unsigned char CDMRData::getSeqNo() const +{ + return m_seqNo; +} + +void CDMRData::setSeqNo(unsigned char seqNo) +{ + m_seqNo = seqNo; +} + +unsigned char CDMRData::getN() const +{ + return m_n; +} + +void CDMRData::setN(unsigned char n) +{ + m_n = n; +} + +unsigned int CDMRData::getData(unsigned char* buffer) const +{ + assert(buffer != NULL); + + ::memcpy(buffer, m_data, DMR_FRAME_LENGTH_BYTES); + + return DMR_FRAME_LENGTH_BYTES; +} + +void CDMRData::setData(const unsigned char* buffer) +{ + assert(buffer != NULL); + + ::memcpy(m_data, buffer, DMR_FRAME_LENGTH_BYTES); +} diff --git a/DMRData.h b/DMRData.h new file mode 100644 index 0000000..7fcc0a3 --- /dev/null +++ b/DMRData.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor, G4KLX + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef DMRData_H +#define DMRData_H + +#include "DMRDefines.h" + +class CDMRData { +public: + CDMRData(const CDMRData& data); + CDMRData(); + ~CDMRData(); + + CDMRData& operator=(const CDMRData& data); + + unsigned int getSlotNo() const; + void setSlotNo(unsigned int slotNo); + + unsigned int getSrcId() const; + void setSrcId(unsigned int id); + + unsigned int getDstId() const; + void setDstId(unsigned int id); + + FLCO getFLCO() const; + void setFLCO(FLCO flco); + + unsigned char getN() const; + void setN(unsigned char n); + + unsigned char getSeqNo() const; + void setSeqNo(unsigned char seqNo); + + unsigned char getDataType() const; + void setDataType(unsigned char dataType); + + void setData(const unsigned char* buffer); + unsigned int getData(unsigned char* buffer) const; + +private: + unsigned int m_slotNo; + unsigned char* m_data; + unsigned int m_srcId; + unsigned int m_dstId; + FLCO m_flco; + unsigned char m_dataType; + unsigned char m_seqNo; + unsigned char m_n; +}; + +#endif diff --git a/DMRDefines.h b/DMRDefines.h new file mode 100644 index 0000000..8e7cada --- /dev/null +++ b/DMRDefines.h @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DMRDefines_H) +#define DMRDefines_H + +const unsigned int DMR_FRAME_LENGTH_BITS = 264U; +const unsigned int DMR_FRAME_LENGTH_BYTES = 33U; + +const unsigned int DMR_SYNC_LENGTH_BITS = 48U; +const unsigned int DMR_SYNC_LENGTH_BYTES = 6U; + +const unsigned int DMR_EMB_LENGTH_BITS = 8U; +const unsigned int DMR_EMB_LENGTH_BYTES = 1U; + +const unsigned int DMR_SLOT_TYPE_LENGTH_BITS = 8U; +const unsigned int DMR_SLOT_TYPE_LENGTH_BYTES = 1U; + +const unsigned int DMR_EMBEDDED_SIGNALLING_LENGTH_BITS = 32U; +const unsigned int DMR_EMBEDDED_SIGNALLING_LENGTH_BYTES = 4U; + +const unsigned int DMR_AMBE_LENGTH_BITS = 108U * 2U; +const unsigned int DMR_AMBE_LENGTH_BYTES = 27U; + +const unsigned char BS_SOURCED_AUDIO_SYNC[] = {0x07U, 0x55U, 0xFDU, 0x7DU, 0xF7U, 0x5FU, 0x70U}; +const unsigned char BS_SOURCED_DATA_SYNC[] = {0x0DU, 0xFFU, 0x57U, 0xD7U, 0x5DU, 0xF5U, 0xD0U}; + +const unsigned char MS_SOURCED_AUDIO_SYNC[] = {0x07U, 0xF7U, 0xD5U, 0xDDU, 0x57U, 0xDFU, 0xD0U}; +const unsigned char MS_SOURCED_DATA_SYNC[] = {0x0DU, 0x5DU, 0x7FU, 0x77U, 0xFDU, 0x75U, 0x70U}; + +const unsigned char DIRECT_SLOT1_AUDIO_SYNC[] = {0x05U, 0xD5U, 0x77U, 0xF7U, 0x75U, 0x7FU, 0xF0U}; +const unsigned char DIRECT_SLOT1_DATA_SYNC[] = {0x0FU, 0x7FU, 0xDDU, 0x5DU, 0xDFU, 0xD5U, 0x50U}; + +const unsigned char DIRECT_SLOT2_AUDIO_SYNC[] = {0x07U, 0xDFU, 0xFDU, 0x5FU, 0x55U, 0xD5U, 0xF0U}; +const unsigned char DIRECT_SLOT2_DATA_SYNC[] = {0x0DU, 0x75U, 0x57U, 0xF5U, 0xFFU, 0x7FU, 0x50U}; + +const unsigned char SYNC_MASK[] = {0x0FU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xF0U}; + +// The PR FILL and Data Sync pattern. +const unsigned char IDLE_DATA[] = + {0x53U, 0xC2U, 0x5EU, 0xABU, 0xA8U, 0x67U, 0x1DU, 0xC7U, 0x38U, 0x3BU, 0xD9U, + 0x36U, 0x00U, 0x0DU, 0xFFU, 0x57U, 0xD7U, 0x5DU, 0xF5U, 0xD0U, 0x03U, 0xF6U, + 0xE4U, 0x65U, 0x17U, 0x1BU, 0x48U, 0xCAU, 0x6DU, 0x4FU, 0xC6U, 0x10U, 0xB4U}; + +const unsigned char PAYLOAD_LEFT_MASK[] = {0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xF0U}; +const unsigned char PAYLOAD_RIGHT_MASK[] = {0x0FU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU}; + +const unsigned char VOICE_LC_HEADER_CRC_MASK[] = {0x96U, 0x96U, 0x96U}; +const unsigned char TERMINATOR_WITH_LC_CRC_MASK[] = {0x99U, 0x99U, 0x99U}; +const unsigned char CSBK_CRC_MASK[] = {0xA5U, 0xA5U}; + +const unsigned int DMR_SLOT_TIME = 60U; +const unsigned int AMBE_PER_SLOT = 3U; + +const unsigned char DT_MASK = 0x0FU; +const unsigned char DT_VOICE_PI_HEADER = 0x00U; +const unsigned char DT_VOICE_LC_HEADER = 0x01U; +const unsigned char DT_TERMINATOR_WITH_LC = 0x02U; +const unsigned char DT_CSBK = 0x03U; +const unsigned char DT_DATA_HEADER = 0x06U; +const unsigned char DT_IDLE = 0x09U; + +// Dummy values +const unsigned char DT_VOICE_SYNC = 0xF0U; +const unsigned char DT_VOICE = 0xF1U; + +const unsigned char DMR_IDLE_RX = 0x80U; +const unsigned char DMR_SYNC_DATA = 0x40U; +const unsigned char DMR_SYNC_AUDIO = 0x20U; + +const unsigned char DMR_SLOT1 = 0x00U; +const unsigned char DMR_SLOT2 = 0x80U; + +const unsigned char FID_ETSI = 0U; +const unsigned char FID_DMRA = 16U; + +enum FLCO { + FLCO_GROUP = 0, + FLCO_USER_USER = 3 +}; + +#endif diff --git a/DMRSlot.cpp b/DMRSlot.cpp new file mode 100644 index 0000000..314a320 --- /dev/null +++ b/DMRSlot.cpp @@ -0,0 +1,718 @@ +/* + * Copyright (C) 2015,2016 Jonathan Naylor, G4KLX + * + * 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; version 2 of the License. + * + * 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. + */ + +#include "SlotType.h" +#include "ShortLC.h" +#include "DMRSlot.h" +#include "Defines.h" +#include "DMRSync.h" +#include "FullLC.h" +#include "CSBK.h" +#include "Utils.h" +#include "EMB.h" +#include "CRC.h" +#include "Log.h" + +#include +#include + +unsigned int CDMRSlot::m_colorCode = 0U; +CModem* CDMRSlot::m_modem = NULL; +CHomebrewDMRIPSC* CDMRSlot::m_network = NULL; +IDisplay* CDMRSlot::m_display = NULL; + +unsigned char* CDMRSlot::m_idle = NULL; + +FLCO CDMRSlot::m_flco1; +unsigned char CDMRSlot::m_id1 = 0U; +FLCO CDMRSlot::m_flco2; +unsigned char CDMRSlot::m_id2 = 0U; + +// #define DUMP_DMR + +CDMRSlot::CDMRSlot(unsigned int slotNo, unsigned int timeout) : +m_slotNo(slotNo), +m_radioQueue(1000U), +m_networkQueue(100U), +m_state(SS_LISTENING), +m_embeddedLC(), +m_lc(NULL), +m_seqNo(0U), +m_n(0U), +m_playoutTimer(1000U, 0U, 500U), +m_networkWatchdog(1000U, 2U), +m_timeoutTimer(1000U, timeout), +m_fp(NULL) +{ +} + +CDMRSlot::~CDMRSlot() +{ +} + +void CDMRSlot::writeModem(unsigned char *data) +{ + if (data[0U] == TAG_LOST && m_state == SS_RELAYING_RF) { + LogMessage("DMR Slot %u, transmission lost", m_slotNo); + writeEndOfTransmission(); + return; + } + + if (data[0U] == TAG_LOST && m_state == SS_LATE_ENTRY) { + m_state = SS_LISTENING; + return; + } + + if (m_state == SS_RELAYING_NETWORK) + return; + + bool dataSync = (data[1U] & DMR_SYNC_DATA) == DMR_SYNC_DATA; + bool audioSync = (data[1U] & DMR_SYNC_AUDIO) == DMR_SYNC_AUDIO; + + if (dataSync) { + CSlotType slotType; + slotType.putData(data + 2U); + + unsigned char colorCode = slotType.getColorCode(); + unsigned char dataType = slotType.getDataType(); + + if (colorCode != m_colorCode) + return; + + if (dataType == DT_VOICE_LC_HEADER) { + if (m_state != SS_RELAYING_RF) { + CFullLC fullLC; + m_lc = fullLC.decode(data + 2U, DT_VOICE_LC_HEADER); + if (m_lc == NULL) { + LogMessage("DMR Slot %u: unable to decode the LC", m_slotNo); + return; + } + + // Regenerate the LC + fullLC.encode(*m_lc, data + 2U, DT_VOICE_LC_HEADER); + + // Regenerate the Slot Type + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + m_n = 0U; + + m_networkWatchdog.stop(); + m_timeoutTimer.start(); + + m_seqNo = 0U; + + for (unsigned i = 0U; i < 3U; i++) { + writeNetwork(data, DT_VOICE_LC_HEADER); + writeRadioQueue(data); + } + + m_state = SS_RELAYING_RF; + setShortLC(m_slotNo, m_lc->getDstId(), m_lc->getFLCO()); + + m_display->writeDMR(m_slotNo, m_lc->getSrcId(), m_lc->getFLCO() == FLCO_GROUP, m_lc->getDstId()); + + LogMessage("DMR Slot %u, received RF header from %u to %s%u", m_slotNo, m_lc->getSrcId(), m_lc->getFLCO() == FLCO_GROUP ? "TG " : "", m_lc->getDstId()); + } + } else if (dataType == DT_VOICE_PI_HEADER) { + if (m_state == SS_RELAYING_RF) { + // Regenerate the Slot Type + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + m_n = 0U; + + writeNetwork(data, DT_VOICE_PI_HEADER); + writeRadioQueue(data); + + LogMessage("DMR Slot %u, received PI header", m_slotNo); + } else { + // Should save the PI header for after we have a valid LC + } + } else { + // Ignore wakeup CSBKs + if (dataType == DT_CSBK) { + CCSBK csbk(data + 2U); + CSBKO csbko = csbk.getCSBKO(); + if (csbko == CSBKO_BSDWNACT) + return; + } + + if (m_state == SS_RELAYING_RF) { + unsigned char end[DMR_FRAME_LENGTH_BYTES + 2U]; + + // Generate the LC + CFullLC fullLC; + fullLC.encode(*m_lc, end + 2U, DT_TERMINATOR_WITH_LC); + + // Generate the Slot Type + CSlotType slotType; + slotType.setColorCode(m_colorCode); + slotType.setDataType(DT_TERMINATOR_WITH_LC); + slotType.getData(end + 2U); + + // Set the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(end + 2U, DST_BS_DATA); + + end[0U] = TAG_EOT; + end[1U] = 0x00U; + + writeNetwork(end, DT_TERMINATOR_WITH_LC); + writeRadioQueue(end); + + LogMessage("DMR Slot %u, received RF end of transmission", m_slotNo); + + // 480ms of idle to space things out + for (unsigned int i = 0U; i < 8U; i++) + writeRadioQueue(m_idle); + + writeEndOfTransmission(); + + if (dataType == DT_TERMINATOR_WITH_LC) + return; + } + + // Regenerate the Slot Type + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + + writeNetwork(data, dataType); + writeRadioQueue(data); + } + } else if (audioSync) { + if (m_state == SS_RELAYING_RF) { + // Convert the Audio Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_AUDIO); + + unsigned char fid = m_lc->getFID(); + if (fid == FID_ETSI || fid == FID_DMRA) + ; // AMBE FEC + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + m_n = 0U; + + writeRadioQueue(data); + writeNetwork(data, DT_VOICE_SYNC); + } else if (m_state == SS_LISTENING) { + m_state = SS_LATE_ENTRY; + } + } else { + if (m_state == SS_RELAYING_RF) { + // Regenerate the EMB + CEMB emb; + emb.putData(data + 2U); + emb.setColorCode(m_colorCode); + emb.getData(data + 2U); + + unsigned char fid = m_lc->getFID(); + if (fid == FID_ETSI || fid == FID_DMRA) + ; // AMBE FEC + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + m_n++; + + writeRadioQueue(data); + writeNetwork(data, DT_VOICE); + } else if (m_state == SS_LATE_ENTRY) { + // If we haven't received an LC yet, then be strict on the color code + CEMB emb; + emb.putData(data + 2U); + unsigned char colorCode = emb.getColorCode(); + if (colorCode != m_colorCode) + return; + + m_lc = m_embeddedLC.addData(data + 2U, emb.getLCSS()); + if (m_lc != NULL) { + // Create a dummy start frame to replace the received frame + unsigned char start[DMR_FRAME_LENGTH_BYTES + 2U]; + + CDMRSync sync; + sync.addSync(start + 2U, DST_BS_DATA); + + CFullLC fullLC; + fullLC.encode(*m_lc, start + 2U, DT_VOICE_LC_HEADER); + + CSlotType slotType; + slotType.setColorCode(m_colorCode); + slotType.setDataType(DT_VOICE_LC_HEADER); + slotType.getData(start + 2U); + + start[0U] = TAG_DATA; + start[1U] = 0x00U; + m_n = 0U; + + m_networkWatchdog.stop(); + m_timeoutTimer.start(); + + m_seqNo = 0U; + + for (unsigned int i = 0U; i < 3U; i++) { + writeNetwork(start, DT_VOICE_LC_HEADER); + writeRadioQueue(start); + } + + // Send the original audio frame out + unsigned char fid = m_lc->getFID(); + if (fid == FID_ETSI || fid == FID_DMRA) + ; // AMBE FEC + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + m_n++; + + writeRadioQueue(data); + writeNetwork(data, DT_VOICE); + + m_state = SS_RELAYING_RF; + + setShortLC(m_slotNo, m_lc->getDstId(), m_lc->getFLCO()); + + m_display->writeDMR(m_slotNo, m_lc->getSrcId(), m_lc->getFLCO() == FLCO_GROUP, m_lc->getDstId()); + + LogMessage("DMR Slot %u, received RF late entry from %u to %s%u", m_slotNo, m_lc->getSrcId(), m_lc->getFLCO() == FLCO_GROUP ? "TG " : "", m_lc->getDstId()); + } + } + } +} + +unsigned int CDMRSlot::readModem(unsigned char* data) +{ + if (m_radioQueue.isEmpty()) + return 0U; + + unsigned char len = 0U; + m_radioQueue.getData(&len, 1U); + + m_radioQueue.getData(data, len); + + return len; +} + +void CDMRSlot::writeEndOfTransmission() +{ + m_state = SS_LISTENING; + + setShortLC(m_slotNo, 0U); + + m_display->clearDMR(m_slotNo); + + m_networkWatchdog.stop(); + m_timeoutTimer.stop(); + + delete m_lc; + m_lc = NULL; +} + +void CDMRSlot::writeNetwork(const CDMRData& dmrData) +{ + if (m_state == SS_RELAYING_RF || m_state == SS_LATE_ENTRY) + return; + + m_networkWatchdog.start(); + + unsigned char dataType = dmrData.getDataType(); + + unsigned char data[DMR_FRAME_LENGTH_BYTES + 2U]; + dmrData.getData(data + 2U); + + if (dataType == DT_VOICE_LC_HEADER) { + if (m_state != SS_RELAYING_NETWORK) { + CFullLC fullLC; + m_lc = fullLC.decode(data + 2U, DT_VOICE_LC_HEADER); + if (m_lc == NULL) + m_lc = new CLC(dmrData.getFLCO(), dmrData.getSrcId(), dmrData.getDstId()); + + // Regenerate the LC + fullLC.encode(*m_lc, data + 2U, DT_VOICE_LC_HEADER); + + // Regenerate the Slot Type + CSlotType slotType; + slotType.setColorCode(m_colorCode); + slotType.setDataType(DT_VOICE_LC_HEADER); + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + + m_playoutTimer.start(); + m_timeoutTimer.start(); + + for (unsigned int i = 0U; i < 3U; i++) + writeNetworkQueue(data); + + m_state = SS_RELAYING_NETWORK; + + setShortLC(m_slotNo, m_lc->getDstId(), m_lc->getFLCO()); + + m_display->writeDMR(m_slotNo, m_lc->getSrcId(), m_lc->getFLCO() == FLCO_GROUP, m_lc->getDstId()); + +#if defined(DUMP_DMR) + openFile(); + writeFile(data); +#endif + LogMessage("DMR Slot %u, received network header from %u to %s%u", m_slotNo, m_lc->getSrcId(), m_lc->getFLCO() == FLCO_GROUP ? "TG " : "", m_lc->getDstId()); + } + } else if (dataType == DT_VOICE_PI_HEADER) { + if (m_state != SS_RELAYING_NETWORK) + return; + + // Regenerate the Slot Type + CSlotType slotType; + slotType.setColorCode(m_colorCode); + slotType.setDataType(DT_VOICE_PI_HEADER); + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + + writeNetworkQueue(data); + +#if defined(DUMP_DMR) + writeFile(data); +#endif + } else if (dataType == DT_TERMINATOR_WITH_LC) { + if (m_state != SS_RELAYING_NETWORK) + return; + + // Regenerate the LC + CFullLC fullLC; + fullLC.encode(*m_lc, data + 2U, DT_TERMINATOR_WITH_LC); + + // Regenerate the Slot Type + CSlotType slotType; + slotType.setColorCode(m_colorCode); + slotType.setDataType(DT_TERMINATOR_WITH_LC); + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_EOT; + data[1U] = 0x00U; + + writeNetworkQueue(data); + writeEndOfTransmission(); + +#if defined(DUMP_DMR) + writeFile(data); + closeFile(); +#endif + LogMessage("DMR Slot %u, received network end of transmission", m_slotNo); + } else if (dataType == DT_VOICE_SYNC) { + if (m_state != SS_RELAYING_NETWORK) + return; + + // Convert the Audio Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_AUDIO); + + unsigned char fid = m_lc->getFID(); + if (fid == FID_ETSI || fid == FID_DMRA) + ; // AMBE FEC + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + + writeNetworkQueue(data); + +#if defined(DUMP_DMR) + writeFile(data); +#endif + } else if (dataType == DT_VOICE) { + if (m_state != SS_RELAYING_NETWORK) + return; + + unsigned char fid = m_lc->getFID(); + if (fid == FID_ETSI || fid == FID_DMRA) + ; // AMBE FEC + + // Change the color code in the EMB + CEMB emb; + emb.putData(data + 2U); + emb.setColorCode(m_colorCode); + emb.getData(data + 2U); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + + writeNetworkQueue(data); + +#if defined(DUMP_DMR) + writeFile(data); +#endif + } else { + if (m_state != SS_RELAYING_NETWORK) + return; + + // Change the Color Code of the Slot Type + CSlotType slotType; + slotType.putData(data + 2U); + slotType.setColorCode(m_colorCode); + slotType.getData(data + 2U); + + // Convert the Data Sync to be from the BS + CDMRSync sync; + sync.addSync(data + 2U, DST_BS_DATA); + + data[0U] = TAG_DATA; + data[1U] = 0x00U; + + writeNetworkQueue(data); + +#if defined(DUMP_DMR) + writeFile(data); +#endif + } +} + +void CDMRSlot::clock(unsigned int ms) +{ + m_timeoutTimer.clock(ms); + + m_playoutTimer.clock(ms); + if (m_playoutTimer.isRunning() && m_playoutTimer.hasExpired()) { + while (!m_networkQueue.isEmpty()) { + unsigned char len = 0U; + m_networkQueue.getData(&len, 1U); + + unsigned char buffer[100U]; + m_networkQueue.getData(buffer, len); + + m_radioQueue.addData(&len, 1U); + m_radioQueue.addData(buffer, len); + } + } + + if (m_state == SS_RELAYING_NETWORK) { + m_networkWatchdog.clock(ms); + + if (m_networkWatchdog.hasExpired()) { + LogMessage("DMR Slot %u, network watchdog has expired", m_slotNo); + writeEndOfTransmission(); +#if defined(DUMP_DMR) + closeFile(); +#endif + } + } +} + +void CDMRSlot::writeRadioQueue(const unsigned char *data) +{ + unsigned char len = DMR_FRAME_LENGTH_BYTES + 2U; + m_radioQueue.addData(&len, 1U); + + // If the timeout has expired, replace the audio with idles to keep the slot busy + if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) + m_radioQueue.addData(m_idle, len); + else + m_radioQueue.addData(data, len); +} + +void CDMRSlot::writeNetworkQueue(const unsigned char *data) +{ + // If the timeout has expired, send nothing + if (!m_timeoutTimer.isRunning() || !m_timeoutTimer.hasExpired()) { + unsigned char len = DMR_FRAME_LENGTH_BYTES + 2U; + m_networkQueue.addData(&len, 1U); + + m_networkQueue.addData(data, len); + } +} + +void CDMRSlot::writeNetwork(const unsigned char* data, unsigned char dataType) +{ + assert(m_lc != NULL); + + if (m_network == NULL) + return; + + // Don't send to the network if the timeout has expired + if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) + return; + + CDMRData dmrData; + dmrData.setSlotNo(m_slotNo); + dmrData.setDataType(dataType); + dmrData.setSrcId(m_lc->getSrcId()); + dmrData.setDstId(m_lc->getDstId()); + dmrData.setFLCO(m_lc->getFLCO()); + dmrData.setN(m_n); + dmrData.setSeqNo(m_seqNo); + + m_seqNo++; + + dmrData.setData(data + 2U); + + m_network->write(dmrData); +} + +void CDMRSlot::init(unsigned int colorCode, CModem* modem, CHomebrewDMRIPSC* network, IDisplay* display) +{ + assert(modem != NULL); + assert(display != NULL); + + m_colorCode = colorCode; + m_modem = modem; + m_network = network; + m_display = display; + + m_idle = new unsigned char[DMR_FRAME_LENGTH_BYTES + 2U]; + + ::memcpy(m_idle + 2U, IDLE_DATA, DMR_FRAME_LENGTH_BYTES); + + // Generate the Slot Type + CSlotType slotType; + slotType.setColorCode(colorCode); + slotType.setDataType(DT_IDLE); + slotType.getData(m_idle + 2U); + + m_idle[0U] = TAG_DATA; + m_idle[1U] = 0x00U; +} + +void CDMRSlot::setShortLC(unsigned int slotNo, unsigned int id, FLCO flco) +{ + assert(m_modem != NULL); + + switch (slotNo) { + case 1U: + m_id1 = 0U; + m_flco1 = flco; + if (id != 0U) { + unsigned char buffer[3U]; + buffer[0U] = (id << 16) & 0xFFU; + buffer[1U] = (id << 8) & 0xFFU; + buffer[2U] = (id << 0) & 0xFFU; + m_id1 = CCRC::crc8(buffer, 3U); + } + break; + case 2U: + m_id2 = 0U; + m_flco2 = flco; + if (id != 0U) { + unsigned char buffer[3U]; + buffer[0U] = (id << 16) & 0xFFU; + buffer[1U] = (id << 8) & 0xFFU; + buffer[2U] = (id << 0) & 0xFFU; + m_id2 = CCRC::crc8(buffer, 3U); + } + break; + default: + LogError("Invalid slot number passed to setShortLC - %u", slotNo); + return; + } + + unsigned char lc[5U]; + lc[0U] = 0x01U; + lc[1U] = 0x00U; + lc[2U] = 0x00U; + lc[3U] = 0x00U; + + if (m_id1 != 0U) { + lc[2U] = m_id1; + if (m_flco1 == FLCO_GROUP) + lc[1U] |= 0x80U; + else + lc[1U] |= 0x90U; + } + + if (m_id2 != 0U) { + lc[3U] = m_id2; + if (m_flco2 == FLCO_GROUP) + lc[1U] |= 0x08U; + else + lc[1U] |= 0x09U; + } + + lc[4U] = CCRC::crc8(lc, 4U); + + unsigned char sLC[9U]; + + CUtils::dump(1U, "Input Short LC", lc, 5U); + + CShortLC shortLC; + shortLC.encode(lc, sLC); + + CUtils::dump(1U, "Output Short LC", sLC, 9U); + + m_modem->writeDMRShortLC(sLC); +} + +bool CDMRSlot::openFile() +{ + if (m_fp != NULL) + return true; + + time_t t; + ::time(&t); + + struct tm* tm = ::localtime(&t); + + char name[100U]; + ::sprintf(name, "DMR_%u_%04d%02d%02d_%02d%02d%02d.ambe", m_slotNo, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); + + m_fp = ::fopen(name, "wb"); + if (m_fp == NULL) + return false; + + ::fwrite("DMR", 1U, 3U, m_fp); + + return true; +} + +bool CDMRSlot::writeFile(const unsigned char* data) +{ + if (m_fp == NULL) + return false; + + ::fwrite(data, 1U, DMR_FRAME_LENGTH_BYTES + 2U, m_fp); + + return true; +} + +void CDMRSlot::closeFile() +{ + if (m_fp != NULL) { + ::fclose(m_fp); + m_fp = NULL; + } +} diff --git a/DMRSlot.h b/DMRSlot.h new file mode 100644 index 0000000..d3d9dc1 --- /dev/null +++ b/DMRSlot.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DMRSlot_H) +#define DMRSlot_H + +#include "HomebrewDMRIPSC.h" +#include "EmbeddedLC.h" +#include "RingBuffer.h" +#include "DMRSlot.h" +#include "DMRData.h" +#include "Display.h" +#include "Timer.h" +#include "Modem.h" +#include "LC.h" + +enum SLOT_STATE { + SS_LISTENING, + SS_LATE_ENTRY, + SS_RELAYING_RF, + SS_RELAYING_NETWORK +}; + +class CDMRSlot { +public: + CDMRSlot(unsigned int slotNo, unsigned int timeout); + ~CDMRSlot(); + + void writeModem(unsigned char* data); + + unsigned int readModem(unsigned char* data); + + void writeNetwork(const CDMRData& data); + + void clock(unsigned int ms); + + static void init(unsigned int colorCode, CModem* modem, CHomebrewDMRIPSC* network, IDisplay* display); + +private: + unsigned int m_slotNo; + CRingBuffer m_radioQueue; + CRingBuffer m_networkQueue; + SLOT_STATE m_state; + CEmbeddedLC m_embeddedLC; + CLC* m_lc; + unsigned char m_seqNo; + unsigned char m_n; + CTimer m_playoutTimer; + CTimer m_networkWatchdog; + CTimer m_timeoutTimer; + FILE* m_fp; + + static unsigned int m_colorCode; + static CModem* m_modem; + static CHomebrewDMRIPSC* m_network; + static IDisplay* m_display; + + static unsigned char* m_idle; + + static FLCO m_flco1; + static unsigned char m_id1; + static FLCO m_flco2; + static unsigned char m_id2; + + void writeRadioQueue(const unsigned char* data); + void writeNetworkQueue(const unsigned char* data); + void writeNetwork(const unsigned char* data, unsigned char dataType); + + void writeEndOfTransmission(); + + bool openFile(); + bool writeFile(const unsigned char* data); + void closeFile(); + + static void setShortLC(unsigned int slotNo, unsigned int id, FLCO flco = FLCO_GROUP); +}; + +#endif diff --git a/DMRSync.cpp b/DMRSync.cpp new file mode 100644 index 0000000..b1bc078 --- /dev/null +++ b/DMRSync.cpp @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "DMRSync.h" +#include "DMRDefines.h" + +#include +#include + +const unsigned int BITS_LOOKUP[] = {0U, 1U, 1U, 2U, 1U, 2U, 2U, 3U, 1U, 2U, 2U, 3U, 2U, 3U, 3U, 4U, + 1U, 2U, 2U, 3U, 2U, 3U, 3U, 4U, 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, + 1U, 2U, 2U, 3U, 2U, 3U, 3U, 4U, 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, + 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, + 1U, 2U, 2U, 3U, 2U, 3U, 3U, 4U, 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, + 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, + 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, + 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, 4U, 5U, 5U, 6U, 5U, 6U, 6U, 7U, + 1U, 2U, 2U, 3U, 2U, 3U, 3U, 4U, 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, + 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, + 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, + 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, 4U, 5U, 5U, 6U, 5U, 6U, 6U, 7U, + 2U, 3U, 3U, 4U, 3U, 4U, 4U, 5U, 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, + 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, 4U, 5U, 5U, 6U, 5U, 6U, 6U, 7U, + 3U, 4U, 4U, 5U, 4U, 5U, 5U, 6U, 4U, 5U, 5U, 6U, 5U, 6U, 6U, 7U, + 4U, 5U, 5U, 6U, 5U, 6U, 6U, 7U, 5U, 6U, 6U, 7U, 6U, 7U, 7U, 8U}; + +const unsigned int THRESHOLD = 4U; + +CDMRSync::CDMRSync() +{ +} + +CDMRSync::~CDMRSync() +{ +} + +DMR_SYNC_TYPE CDMRSync::matchDirectSync(const unsigned char* bytes) const +{ + assert(bytes != NULL); + + unsigned int diffs = compareBytes(bytes + 13U, DIRECT_SLOT1_AUDIO_SYNC); + if (diffs < THRESHOLD) + return DST_DIRECT_SLOT1_AUDIO; + + diffs = compareBytes(bytes + 13U, DIRECT_SLOT2_AUDIO_SYNC); + if (diffs < THRESHOLD) + return DST_DIRECT_SLOT2_AUDIO; + + diffs = compareBytes(bytes + 13U, DIRECT_SLOT1_DATA_SYNC); + if (diffs < THRESHOLD) + return DST_DIRECT_SLOT1_DATA; + + diffs = compareBytes(bytes + 13U, DIRECT_SLOT2_DATA_SYNC); + if (diffs < THRESHOLD) + return DST_DIRECT_SLOT2_DATA; + + return DST_NONE; +} + +DMR_SYNC_TYPE CDMRSync::matchMSSync(const unsigned char* bytes) const +{ + assert(bytes != NULL); + + unsigned int diffs = compareBytes(bytes + 13U, MS_SOURCED_AUDIO_SYNC); + if (diffs < THRESHOLD) + return DST_MS_AUDIO; + + diffs = compareBytes(bytes + 13U, MS_SOURCED_DATA_SYNC); + if (diffs < THRESHOLD) + return DST_MS_DATA; + + return DST_NONE; +} + +DMR_SYNC_TYPE CDMRSync::matchBSSync(const unsigned char* bytes) const +{ + assert(bytes != NULL); + + unsigned int diffs = compareBytes(bytes + 13U, BS_SOURCED_AUDIO_SYNC); + if (diffs < THRESHOLD) + return DST_BS_AUDIO; + + diffs = compareBytes(bytes + 13U, BS_SOURCED_DATA_SYNC); + if (diffs < THRESHOLD) + return DST_BS_DATA; + + return DST_NONE; +} + +void CDMRSync::addSync(unsigned char* data, DMR_SYNC_TYPE type) const +{ + assert(data != NULL); + + const unsigned char* sync = NULL; + switch (type) { + case DST_BS_AUDIO: + sync = BS_SOURCED_AUDIO_SYNC; + break; + case DST_BS_DATA: + sync = BS_SOURCED_DATA_SYNC; + break; + case DST_MS_AUDIO: + sync = MS_SOURCED_AUDIO_SYNC; + break; + case DST_MS_DATA: + sync = MS_SOURCED_DATA_SYNC; + break; + case DST_DIRECT_SLOT1_AUDIO: + sync = DIRECT_SLOT1_AUDIO_SYNC; + break; + case DST_DIRECT_SLOT1_DATA: + sync = DIRECT_SLOT1_DATA_SYNC; + break; + case DST_DIRECT_SLOT2_AUDIO: + sync = DIRECT_SLOT2_AUDIO_SYNC; + break; + case DST_DIRECT_SLOT2_DATA: + sync = DIRECT_SLOT2_DATA_SYNC; + break; + default: + return; + } + + for (unsigned int i = 0U; i < 7U; i++) + data[i + 13U] = (data[i + 13U] & ~SYNC_MASK[i]) | sync[i]; +} + +unsigned int CDMRSync::compareBytes(const unsigned char *bytes1, const unsigned char* bytes2) const +{ + assert(bytes1 != NULL); + assert(bytes2 != NULL); + + unsigned int diffs = 0U; + for (unsigned int i = 0U; i < 7U; i++) { + unsigned char b = SYNC_MASK[i] & (bytes1[i] ^ bytes2[i]); + diffs += BITS_LOOKUP[b]; + } + + return diffs; +} diff --git a/DMRSync.h b/DMRSync.h new file mode 100644 index 0000000..8534543 --- /dev/null +++ b/DMRSync.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DMRSYNC_H) +#define DMRSYNC_H + +enum DMR_SYNC_TYPE { + DST_BS_AUDIO, + DST_BS_DATA, + + DST_MS_AUDIO, + DST_MS_DATA, + + DST_DIRECT_SLOT1_AUDIO, + DST_DIRECT_SLOT1_DATA, + + DST_DIRECT_SLOT2_AUDIO, + DST_DIRECT_SLOT2_DATA, + + DST_NONE +}; + +class CDMRSync +{ +public: + CDMRSync(); + ~CDMRSync(); + + DMR_SYNC_TYPE matchDirectSync(const unsigned char* bytes) const; + + DMR_SYNC_TYPE matchMSSync(const unsigned char* bytes) const; + + DMR_SYNC_TYPE matchBSSync(const unsigned char* bytes) const; + + void addSync(unsigned char* data, DMR_SYNC_TYPE type) const; + +private: + unsigned int compareBytes(const unsigned char* bytes1, const unsigned char* bytes2) const; +}; + +#endif diff --git a/DStarDefines.h b/DStarDefines.h new file mode 100644 index 0000000..9c3fbea --- /dev/null +++ b/DStarDefines.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DStarDefines_H) +#define DStarDefines_H + +const unsigned int DSTAR_HEADER_LENGTH_BYTES = 41U; +const unsigned int DSTAR_FRAME_LENGTH_BYTES = 12U; + +// Check this +const unsigned char DSTAR_SYNC_BYTES[] = {0x55U, 0x2DU, 0x16U}; + +#endif diff --git a/DStarEcho.cpp b/DStarEcho.cpp new file mode 100644 index 0000000..8398e20 --- /dev/null +++ b/DStarEcho.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "DStarEcho.h" + +CDStarEcho::CDStarEcho(unsigned int delay, unsigned int space) : +m_buffer(space), +m_timer(1000U, delay) +{ +} + +CDStarEcho::~CDStarEcho() +{ +} + +unsigned int CDStarEcho::readData(unsigned char* data) +{ + if (!hasData()) + return 0U; + + unsigned char len; + m_buffer.getData(&len, 1U); + + m_buffer.getData(data, len); + + if (!hasData()) + m_timer.stop(); + + return len; +} + +bool CDStarEcho::writeData(const unsigned char* data, unsigned int length) +{ + bool ret = m_buffer.hasSpace(length + 1U); + if (!ret) + return false; + + unsigned char len = length; + m_buffer.addData(&len, 1U); + + m_buffer.addData(data, length); + + m_timer.start(); + + return true; +} + +bool CDStarEcho::hasData() +{ + if (m_timer.isRunning() && m_timer.hasExpired()) + return m_buffer.hasData(); + else + return false; +} + +void CDStarEcho::clock(unsigned int ms) +{ + m_timer.clock(ms); +} diff --git a/DStarEcho.h b/DStarEcho.h new file mode 100644 index 0000000..b667c92 --- /dev/null +++ b/DStarEcho.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DSTARECHO_H) +#define DSTARECHO_H + +#include "RingBuffer.h" +#include "Timer.h" + +class CDStarEcho { +public: + CDStarEcho(unsigned int delay, unsigned int space); + ~CDStarEcho(); + + unsigned int readData(unsigned char* data); + + bool writeData(const unsigned char* data, unsigned int length); + + bool hasData(); + + void clock(unsigned int ms); + +private: + CRingBuffer m_buffer; + CTimer m_timer; +}; + +#endif diff --git a/Defines.h b/Defines.h new file mode 100644 index 0000000..4fd684a --- /dev/null +++ b/Defines.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(Defines_H) +#define Defines_H + +const unsigned char MODE_IDLE = 0U; +const unsigned char MODE_DSTAR = 1U; +const unsigned char MODE_DMR = 2U; +const unsigned char MODE_YSF = 3U; + +const unsigned char TAG_HEADER = 0x00U; +const unsigned char TAG_DATA = 0x01U; +const unsigned char TAG_LOST = 0x02U; +const unsigned char TAG_EOT = 0x03U; + +#endif diff --git a/Display.cpp b/Display.cpp new file mode 100644 index 0000000..54b514b --- /dev/null +++ b/Display.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "Display.h" + +IDisplay::~IDisplay() +{ +} diff --git a/Display.h b/Display.h new file mode 100644 index 0000000..1318832 --- /dev/null +++ b/Display.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(DISPLAY_H) +#define DISPLAY_H + +#include + +class IDisplay +{ +public: + virtual ~IDisplay() = 0; + + virtual bool open() = 0; + + virtual void setIdle() = 0; + + virtual void setDStar() = 0; + virtual void writeDStar(const std::string& call1, const std::string& call2) = 0; + virtual void clearDStar() = 0; + + virtual void setDMR() = 0; + virtual void writeDMR(unsigned int slotNo, unsigned int srdId, bool group, unsigned int dstId) = 0; + virtual void clearDMR(unsigned int slotNo) = 0; + + virtual void setFusion() = 0; + virtual void writeFusion(const std::string& callsign) = 0; + virtual void clearFusion() = 0; + + virtual void close() = 0; + +private: +}; + +#endif diff --git a/EMB.cpp b/EMB.cpp new file mode 100644 index 0000000..c2053df --- /dev/null +++ b/EMB.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "EMB.h" + +#include "QR1676.h" + +#include +#include + +CEMB::CEMB() : +m_colorCode(0U), +m_PI(false), +m_LCSS(0U) +{ +} + +CEMB::~CEMB() +{ +} + +void CEMB::putData(const unsigned char* data) +{ + assert(data != NULL); + + unsigned char emb[2U]; + emb[0U] = (data[13U] << 4) & 0xF0U; + emb[0U] |= (data[14U] >> 4) & 0x0FU; + emb[1U] = (data[18U] << 4) & 0xF0U; + emb[1U] |= (data[19U] >> 4) & 0x0FU; + + CQR1676::decode(emb); + + m_colorCode = (emb[0U] >> 4) & 0x0FU; + m_PI = (emb[0U] & 0x08U) == 0x08U; + m_LCSS = (emb[0U] >> 1) & 0x03U; +} + +void CEMB::getData(unsigned char* data) const +{ + assert(data != NULL); + + unsigned char emb[2U]; + emb[0U] = (m_colorCode << 4) & 0xF0U; + emb[0U] |= m_PI ? 0x08U : 0x00U; + emb[0U] |= (m_LCSS << 1) & 0x06U; + emb[1U] = 0x00U; + + CQR1676::encode(emb); + + data[13U] = (data[13U] & 0xF0U) | ((emb[0U] >> 4U) & 0x0FU); + data[14U] = (data[14U] & 0x0FU) | ((emb[0U] << 4U) & 0xF0U); + data[18U] = (data[18U] & 0xF0U) | ((emb[1U] >> 4U) & 0x0FU); + data[19U] = (data[19U] & 0x0FU) | ((emb[1U] << 4U) & 0xF0U); +} + +unsigned char CEMB::getColorCode() const +{ + return m_colorCode; +} + +void CEMB::setColorCode(unsigned char code) +{ + m_colorCode = code; +} + +bool CEMB::getPI() const +{ + return m_PI; +} + +void CEMB::setPI(bool pi) +{ + m_PI = pi; +} + +unsigned char CEMB::getLCSS() const +{ + return m_LCSS; +} + +void CEMB::setLCSS(unsigned char lcss) +{ + m_LCSS = lcss; +} diff --git a/EMB.h b/EMB.h new file mode 100644 index 0000000..4283c6b --- /dev/null +++ b/EMB.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(EMB_H) +#define EMB_H + +class CEMB +{ +public: + CEMB(); + ~CEMB(); + + void putData(const unsigned char* data); + void getData(unsigned char* data) const; + + unsigned char getColorCode() const; + void setColorCode(unsigned char code); + + bool getPI() const; + void setPI(bool pi); + + unsigned char getLCSS() const; + void setLCSS(unsigned char lcss); + +private: + unsigned char m_colorCode; + bool m_PI; + unsigned char m_LCSS; +}; + +#endif + diff --git a/EmbeddedLC.cpp b/EmbeddedLC.cpp new file mode 100644 index 0000000..c70ac7d --- /dev/null +++ b/EmbeddedLC.cpp @@ -0,0 +1,266 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "EmbeddedLC.h" + +#include "Hamming.h" +#include "Utils.h" +#include "CRC.h" +#include "Log.h" + +#include +#include +#include + +CEmbeddedLC::CEmbeddedLC() : +m_rawLC(NULL), +m_state(LCS_NONE) +{ + m_rawLC = new bool[128U]; +} + +CEmbeddedLC::~CEmbeddedLC() +{ + delete[] m_rawLC; +} + +// Add LC data (which may consist of 4 blocks) to the data store +CLC* CEmbeddedLC::addData(const unsigned char* data, unsigned char lcss) +{ + assert(data != NULL); + + bool rawData[40U]; + CUtils::byteToBitsBE(data[14U], rawData + 0U); + CUtils::byteToBitsBE(data[15U], rawData + 8U); + CUtils::byteToBitsBE(data[16U], rawData + 16U); + CUtils::byteToBitsBE(data[17U], rawData + 24U); + CUtils::byteToBitsBE(data[18U], rawData + 32U); + + // Is this the first block of a 4 block embedded LC ? + if (lcss == 1U) { + for (unsigned int a = 0U; a < 32U; a++) + m_rawLC[a] = rawData[a + 4U]; + + // Show we are ready for the next LC block + m_state = LCS_FIRST; + return NULL; + } + + // Is this the 2nd block of a 4 block embedded LC ? + if (lcss == 3U && m_state == LCS_FIRST) { + for (unsigned int a = 0U; a < 32U; a++) + m_rawLC[a + 32U] = rawData[a + 4U]; + + // Show we are ready for the next LC block + m_state = LCS_SECOND; + return NULL; + } + + // Is this the 3rd block of a 4 block embedded LC ? + if (lcss == 3U && m_state == LCS_SECOND) { + for (unsigned int a = 0U; a < 32U; a++) + m_rawLC[a + 64U] = rawData[a + 4U]; + + // Show we are ready for the final LC block + m_state = LCS_THIRD; + return NULL; + } + + // Is this the final block of a 4 block embedded LC ? + if (lcss == 2U && m_state == LCS_THIRD) { + for (unsigned int a = 0U; a < 32U; a++) + m_rawLC[a + 96U] = rawData[a + 4U]; + + // Process the complete data block + return processMultiBlockEmbeddedLC(); + } + + // Is this a single block embedded LC + if (lcss == 0U) { + processSingleBlockEmbeddedLC(rawData + 4U); + return NULL; + } + + return NULL; +} + +void CEmbeddedLC::setData(const CLC& lc) +{ + bool lcData[72U]; + lc.getData(lcData); + + unsigned int crc; + CCRC::encodeFiveBit(lcData, crc); + + bool data[128U]; + ::memset(data, 0x00U, 128U * sizeof(bool)); + + data[106U] = (crc & 0x01U) == 0x01U; + data[90U] = (crc & 0x02U) == 0x02U; + data[74U] = (crc & 0x04U) == 0x04U; + data[58U] = (crc & 0x08U) == 0x08U; + data[42U] = (crc & 0x10U) == 0x10U; + + unsigned int b = 0U; + for (unsigned int a = 0U; a < 11U; a++, b++) + data[a] = lcData[b]; + for (unsigned int a = 16U; a < 27U; a++, b++) + data[a] = lcData[b]; + for (unsigned int a = 32U; a < 42U; a++, b++) + data[a] = lcData[b]; + for (unsigned int a = 48U; a < 58U; a++, b++) + data[a] = lcData[b]; + for (unsigned int a = 64U; a < 74U; a++, b++) + data[a] = lcData[b]; + for (unsigned int a = 80U; a < 90U; a++, b++) + data[a] = lcData[b]; + for (unsigned int a = 96U; a < 106U; a++, b++) + data[a] = lcData[b]; + + // Hamming (16,11,4) check each row except the last one + for (unsigned int a = 0U; a < 112U; a += 16U) + CHamming::encode16114(data + a); + + // Add the parity bits for each column + for (unsigned int a = 0U; a < 16U; a++) + data[a + 112U] = data[a + 0U] ^ data[a + 16U] ^ data[a + 32U] ^ data[a + 48U] ^ data[a + 64U] ^ data[a + 80U] ^ data[a + 96U]; + + // The data is packed downwards in columns + b = 0U; + for (unsigned int a = 0U; a < 128U; a++) { + m_rawLC[a] = data[b]; + b += 16U; + if (b > 127U) + b -= 127U; + } +} + +unsigned int CEmbeddedLC::getData(unsigned char* data, unsigned int n) const +{ + assert(data != NULL); + + if (n < 4U) { + bool bits[40U]; + ::memset(bits, 0x00U, 40U * sizeof(bool)); + ::memcpy(bits + 4U, m_rawLC + n * 32U, 32U * sizeof(bool)); + + unsigned char bytes[5U]; + CUtils::bitsToByteBE(bits + 0U, bytes[0U]); + CUtils::bitsToByteBE(bits + 8U, bytes[1U]); + CUtils::bitsToByteBE(bits + 16U, bytes[2U]); + CUtils::bitsToByteBE(bits + 24U, bytes[3U]); + CUtils::bitsToByteBE(bits + 32U, bytes[4U]); + + data[14U] = (data[14U] & 0xF0U) | (bytes[0U] & 0x0FU); + data[15U] = bytes[1U]; + data[16U] = bytes[2U]; + data[17U] = bytes[3U]; + data[18U] = (data[18U] & 0x0FU) | (bytes[4U] & 0xF0U); + } else { + data[14U] &= 0xF0U; + data[15U] = 0x00U; + data[16U] = 0x00U; + data[17U] = 0x00U; + data[18U] &= 0x0FU; + } + + switch (n) { + case 0U: + return 1U; + case 1U: + case 2U: + return 3U; + case 3U: + return 2U; + default: + return 0U; + } +} + +// Unpack and error check an embedded LC +CLC* CEmbeddedLC::processMultiBlockEmbeddedLC() +{ + // The data is unpacked downwards in columns + bool data[128U]; + ::memset(data, 0x00U, 128U * sizeof(bool)); + + unsigned int b = 0U; + for (unsigned int a = 0U; a < 128U; a++) { + data[b] = m_rawLC[a]; + b += 16U; + if (b > 127U) + b -= 127U; + } + + // Hamming (16,11,4) check each row except the last one + for (unsigned int a = 0U; a < 112U; a += 16U) { + if (!CHamming::decode16114(data + a)) { + ::LogDebug("Hamming decode of a row of the Embedded LC failed"); + return NULL; + } + } + + // Check the parity bits + for (unsigned int a = 0U; a < 16U; a++) { + bool parity = data[a + 0U] ^ data[a + 16U] ^ data[a + 32U] ^ data[a + 48U] ^ data[a + 64U] ^ data[a + 80U] ^ data[a + 96U] ^ data[a + 112U]; + if (parity) { + ::LogDebug("Parity check of a column of the Embedded LC failed"); + return NULL; + } + } + + // We have passed the Hamming check so extract the actual payload + bool lcData[72U]; + b = 0U; + for (unsigned int a = 0U; a < 11U; a++, b++) + lcData[b] = data[a]; + for (unsigned int a = 16U; a < 27U; a++, b++) + lcData[b] = data[a]; + for (unsigned int a = 32U; a < 42U; a++, b++) + lcData[b] = data[a]; + for (unsigned int a = 48U; a < 58U; a++, b++) + lcData[b] = data[a]; + for (unsigned int a = 64U; a < 74U; a++, b++) + lcData[b] = data[a]; + for (unsigned int a = 80U; a < 90U; a++, b++) + lcData[b] = data[a]; + for (unsigned int a = 96U; a < 106U; a++, b++) + lcData[b] = data[a]; + + // Extract the 5 bit CRC + unsigned int crc = 0U; + if (data[42]) crc += 16U; + if (data[58]) crc += 8U; + if (data[74]) crc += 4U; + if (data[90]) crc += 2U; + if (data[106]) crc += 1U; + + // Now CRC check this + if (!CCRC::checkFiveBit(lcData, crc)) { + ::LogDebug("Checksum of the Embedded LC failed"); + return NULL; + } + + return new CLC(lcData); +} + +// Deal with a single block embedded LC +void CEmbeddedLC::processSingleBlockEmbeddedLC(const bool* data) +{ + // Nothing interesting, or just NULL (I think) +} diff --git a/EmbeddedLC.h b/EmbeddedLC.h new file mode 100644 index 0000000..f7c762b --- /dev/null +++ b/EmbeddedLC.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef EmbeddedLC_H +#define EmbeddedLC_H + +#include "LC.h" + +enum LC_STATE { + LCS_NONE, + LCS_FIRST, + LCS_SECOND, + LCS_THIRD +}; + +class CEmbeddedLC +{ +public: + CEmbeddedLC(); + ~CEmbeddedLC(); + + CLC* addData(const unsigned char* data, unsigned char lcss); + + void setData(const CLC& lc); + unsigned int getData(unsigned char* data, unsigned int n) const; + +private: + bool* m_rawLC; + LC_STATE m_state; + + CLC* processMultiBlockEmbeddedLC(); + void processSingleBlockEmbeddedLC(const bool* data); +}; + +#endif + diff --git a/FullLC.cpp b/FullLC.cpp new file mode 100644 index 0000000..135678a --- /dev/null +++ b/FullLC.cpp @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2012 by Ian Wraith + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "FullLC.h" +#include "Log.h" +#include "DMRDefines.h" +#include "RS129.h" + +#include +#include + +CFullLC::CFullLC() : +m_bptc() +{ +} + +CFullLC::~CFullLC() +{ +} + +CLC* CFullLC::decode(const unsigned char* data, unsigned char type) +{ + assert(data != NULL); + + unsigned char lcData[12U]; + m_bptc.decode(data, lcData); + + switch (type) { + case DT_VOICE_LC_HEADER: + lcData[9U] ^= VOICE_LC_HEADER_CRC_MASK[0U]; + lcData[10U] ^= VOICE_LC_HEADER_CRC_MASK[1U]; + lcData[11U] ^= VOICE_LC_HEADER_CRC_MASK[2U]; + break; + + case DT_TERMINATOR_WITH_LC: + lcData[9U] ^= TERMINATOR_WITH_LC_CRC_MASK[0U]; + lcData[10U] ^= TERMINATOR_WITH_LC_CRC_MASK[1U]; + lcData[11U] ^= TERMINATOR_WITH_LC_CRC_MASK[2U]; + break; + + default: + ::LogError("Unsupported LC type - %d", int(type)); + return NULL; + } + + if (!CRS129::check(lcData)) { + ::LogDebug("Checksum failed for the LC"); + CLC lc(lcData); + LogDebug("Invalid LC, src = %u, dst = %s%u", lc.getSrcId(), lc.getFLCO() == FLCO_GROUP ? "TG " : "", lc.getDstId()); + return NULL; + } + + return new CLC(lcData); +} + +void CFullLC::encode(const CLC& lc, unsigned char* data, unsigned char type) +{ + assert(data != NULL); + + unsigned char lcData[12U]; + lc.getData(lcData); + + unsigned char parity[4U]; + CRS129::encode(lcData, 9U, parity); + + switch (type) { + case DT_VOICE_LC_HEADER: + lcData[9U] = parity[2U] ^ VOICE_LC_HEADER_CRC_MASK[0U]; + lcData[10U] = parity[1U] ^ VOICE_LC_HEADER_CRC_MASK[1U]; + lcData[11U] = parity[0U] ^ VOICE_LC_HEADER_CRC_MASK[2U]; + break; + + case DT_TERMINATOR_WITH_LC: + lcData[9U] = parity[2U] ^ TERMINATOR_WITH_LC_CRC_MASK[0U]; + lcData[10U] = parity[1U] ^ TERMINATOR_WITH_LC_CRC_MASK[1U]; + lcData[11U] = parity[0U] ^ TERMINATOR_WITH_LC_CRC_MASK[2U]; + break; + + default: + ::LogError("Unsupported LC type - %d", int(type)); + return; + } + + m_bptc.encode(lcData, data); +} diff --git a/FullLC.h b/FullLC.h new file mode 100644 index 0000000..28ba8cf --- /dev/null +++ b/FullLC.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef FullLC_H +#define FullLC_H + +#include "LC.h" +#include "SlotType.h" + +#include "BPTC19696.h" + +class CFullLC +{ +public: + CFullLC(); + ~CFullLC(); + + CLC* decode(const unsigned char* data, unsigned char type); + + void encode(const CLC& lc, unsigned char* data, unsigned char type); + +private: + CBPTC19696 m_bptc; +}; + +#endif + diff --git a/Golay2087.cpp b/Golay2087.cpp new file mode 100644 index 0000000..61942d8 --- /dev/null +++ b/Golay2087.cpp @@ -0,0 +1,262 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "Golay2087.h" + +#include +#include + +const unsigned int ENCODING_TABLE_2087[] = + {0x0000U, 0xB08EU, 0xE093U, 0x501DU, 0x70A9U, 0xC027U, 0x903AU, 0x20B4U, 0x60DCU, 0xD052U, 0x804FU, 0x30C1U, + 0x1075U, 0xA0FBU, 0xF0E6U, 0x4068U, 0x7036U, 0xC0B8U, 0x90A5U, 0x202BU, 0x009FU, 0xB011U, 0xE00CU, 0x5082U, + 0x10EAU, 0xA064U, 0xF079U, 0x40F7U, 0x6043U, 0xD0CDU, 0x80D0U, 0x305EU, 0xD06CU, 0x60E2U, 0x30FFU, 0x8071U, + 0xA0C5U, 0x104BU, 0x4056U, 0xF0D8U, 0xB0B0U, 0x003EU, 0x5023U, 0xE0ADU, 0xC019U, 0x7097U, 0x208AU, 0x9004U, + 0xA05AU, 0x10D4U, 0x40C9U, 0xF047U, 0xD0F3U, 0x607DU, 0x3060U, 0x80EEU, 0xC086U, 0x7008U, 0x2015U, 0x909BU, + 0xB02FU, 0x00A1U, 0x50BCU, 0xE032U, 0x90D9U, 0x2057U, 0x704AU, 0xC0C4U, 0xE070U, 0x50FEU, 0x00E3U, 0xB06DU, + 0xF005U, 0x408BU, 0x1096U, 0xA018U, 0x80ACU, 0x3022U, 0x603FU, 0xD0B1U, 0xE0EFU, 0x5061U, 0x007CU, 0xB0F2U, + 0x9046U, 0x20C8U, 0x70D5U, 0xC05BU, 0x8033U, 0x30BDU, 0x60A0U, 0xD02EU, 0xF09AU, 0x4014U, 0x1009U, 0xA087U, + 0x40B5U, 0xF03BU, 0xA026U, 0x10A8U, 0x301CU, 0x8092U, 0xD08FU, 0x6001U, 0x2069U, 0x90E7U, 0xC0FAU, 0x7074U, + 0x50C0U, 0xE04EU, 0xB053U, 0x00DDU, 0x3083U, 0x800DU, 0xD010U, 0x609EU, 0x402AU, 0xF0A4U, 0xA0B9U, 0x1037U, + 0x505FU, 0xE0D1U, 0xB0CCU, 0x0042U, 0x20F6U, 0x9078U, 0xC065U, 0x70EBU, 0xA03DU, 0x10B3U, 0x40AEU, 0xF020U, + 0xD094U, 0x601AU, 0x3007U, 0x8089U, 0xC0E1U, 0x706FU, 0x2072U, 0x90FCU, 0xB048U, 0x00C6U, 0x50DBU, 0xE055U, + 0xD00BU, 0x6085U, 0x3098U, 0x8016U, 0xA0A2U, 0x102CU, 0x4031U, 0xF0BFU, 0xB0D7U, 0x0059U, 0x5044U, 0xE0CAU, + 0xC07EU, 0x70F0U, 0x20EDU, 0x9063U, 0x7051U, 0xC0DFU, 0x90C2U, 0x204CU, 0x00F8U, 0xB076U, 0xE06BU, 0x50E5U, + 0x108DU, 0xA003U, 0xF01EU, 0x4090U, 0x6024U, 0xD0AAU, 0x80B7U, 0x3039U, 0x0067U, 0xB0E9U, 0xE0F4U, 0x507AU, + 0x70CEU, 0xC040U, 0x905DU, 0x20D3U, 0x60BBU, 0xD035U, 0x8028U, 0x30A6U, 0x1012U, 0xA09CU, 0xF081U, 0x400FU, + 0x30E4U, 0x806AU, 0xD077U, 0x60F9U, 0x404DU, 0xF0C3U, 0xA0DEU, 0x1050U, 0x5038U, 0xE0B6U, 0xB0ABU, 0x0025U, + 0x2091U, 0x901FU, 0xC002U, 0x708CU, 0x40D2U, 0xF05CU, 0xA041U, 0x10CFU, 0x307BU, 0x80F5U, 0xD0E8U, 0x6066U, + 0x200EU, 0x9080U, 0xC09DU, 0x7013U, 0x50A7U, 0xE029U, 0xB034U, 0x00BAU, 0xE088U, 0x5006U, 0x001BU, 0xB095U, + 0x9021U, 0x20AFU, 0x70B2U, 0xC03CU, 0x8054U, 0x30DAU, 0x60C7U, 0xD049U, 0xF0FDU, 0x4073U, 0x106EU, 0xA0E0U, + 0x90BEU, 0x2030U, 0x702DU, 0xC0A3U, 0xE017U, 0x5099U, 0x0084U, 0xB00AU, 0xF062U, 0x40ECU, 0x10F1U, 0xA07FU, + 0x80CBU, 0x3045U, 0x6058U, 0xD0D6U}; + +const unsigned int DECODING_TABLE_1987[] = + {0x00000U, 0x00001U, 0x00002U, 0x00003U, 0x00004U, 0x00005U, 0x00006U, 0x00007U, 0x00008U, 0x00009U, 0x0000AU, 0x0000BU, 0x0000CU, + 0x0000DU, 0x0000EU, 0x24020U, 0x00010U, 0x00011U, 0x00012U, 0x00013U, 0x00014U, 0x00015U, 0x00016U, 0x00017U, 0x00018U, 0x00019U, + 0x0001AU, 0x0001BU, 0x0001CU, 0x0001DU, 0x48040U, 0x01480U, 0x00020U, 0x00021U, 0x00022U, 0x00023U, 0x00024U, 0x00025U, 0x00026U, + 0x24008U, 0x00028U, 0x00029U, 0x0002AU, 0x24004U, 0x0002CU, 0x24002U, 0x24001U, 0x24000U, 0x00030U, 0x00031U, 0x00032U, 0x08180U, + 0x00034U, 0x00C40U, 0x00036U, 0x00C42U, 0x00038U, 0x43000U, 0x0003AU, 0x43002U, 0x02902U, 0x24012U, 0x02900U, 0x24010U, 0x00040U, + 0x00041U, 0x00042U, 0x00043U, 0x00044U, 0x00045U, 0x00046U, 0x00047U, 0x00048U, 0x00049U, 0x0004AU, 0x02500U, 0x0004CU, 0x0004DU, + 0x48010U, 0x48011U, 0x00050U, 0x00051U, 0x00052U, 0x21200U, 0x00054U, 0x00C20U, 0x48008U, 0x48009U, 0x00058U, 0x00059U, 0x48004U, + 0x48005U, 0x48002U, 0x48003U, 0x48000U, 0x48001U, 0x00060U, 0x00061U, 0x00062U, 0x00063U, 0x00064U, 0x00C10U, 0x10300U, 0x0B000U, + 0x00068U, 0x00069U, 0x01880U, 0x01881U, 0x40181U, 0x40180U, 0x24041U, 0x24040U, 0x00070U, 0x00C04U, 0x00072U, 0x00C06U, 0x00C01U, + 0x00C00U, 0x00C03U, 0x00C02U, 0x05204U, 0x00C0CU, 0x48024U, 0x48025U, 0x05200U, 0x00C08U, 0x48020U, 0x48021U, 0x00080U, 0x00081U, + 0x00082U, 0x00083U, 0x00084U, 0x00085U, 0x00086U, 0x00087U, 0x00088U, 0x00089U, 0x0008AU, 0x50200U, 0x0008CU, 0x0A800U, 0x01411U, + 0x01410U, 0x00090U, 0x00091U, 0x00092U, 0x08120U, 0x00094U, 0x00095U, 0x04A00U, 0x01408U, 0x00098U, 0x00099U, 0x01405U, 0x01404U, + 0x01403U, 0x01402U, 0x01401U, 0x01400U, 0x000A0U, 0x000A1U, 0x000A2U, 0x08110U, 0x000A4U, 0x000A5U, 0x42400U, 0x42401U, 0x000A8U, + 0x000A9U, 0x01840U, 0x01841U, 0x40141U, 0x40140U, 0x24081U, 0x24080U, 0x000B0U, 0x08102U, 0x08101U, 0x08100U, 0x000B4U, 0x08106U, + 0x08105U, 0x08104U, 0x20A01U, 0x20A00U, 0x08109U, 0x08108U, 0x01423U, 0x01422U, 0x01421U, 0x01420U, 0x000C0U, 0x000C1U, 0x000C2U, + 0x000C3U, 0x000C4U, 0x000C5U, 0x000C6U, 0x000C7U, 0x000C8U, 0x000C9U, 0x01820U, 0x01821U, 0x20600U, 0x40120U, 0x16000U, 0x16001U, + 0x000D0U, 0x000D1U, 0x42801U, 0x42800U, 0x03100U, 0x18200U, 0x03102U, 0x18202U, 0x000D8U, 0x000D9U, 0x48084U, 0x01444U, 0x48082U, + 0x01442U, 0x48080U, 0x01440U, 0x000E0U, 0x32000U, 0x01808U, 0x04600U, 0x40109U, 0x40108U, 0x0180CU, 0x4010AU, 0x01802U, 0x40104U, + 0x01800U, 0x01801U, 0x40101U, 0x40100U, 0x01804U, 0x40102U, 0x0A408U, 0x08142U, 0x08141U, 0x08140U, 0x00C81U, 0x00C80U, 0x00C83U, + 0x00C82U, 0x0A400U, 0x0A401U, 0x01810U, 0x01811U, 0x40111U, 0x40110U, 0x01814U, 0x40112U, 0x00100U, 0x00101U, 0x00102U, 0x00103U, + 0x00104U, 0x00105U, 0x00106U, 0x41800U, 0x00108U, 0x00109U, 0x0010AU, 0x02440U, 0x0010CU, 0x0010DU, 0x0010EU, 0x02444U, 0x00110U, + 0x00111U, 0x00112U, 0x080A0U, 0x00114U, 0x00115U, 0x00116U, 0x080A4U, 0x00118U, 0x00119U, 0x15000U, 0x15001U, 0x02822U, 0x02823U, + 0x02820U, 0x02821U, 0x00120U, 0x00121U, 0x00122U, 0x08090U, 0x00124U, 0x00125U, 0x10240U, 0x10241U, 0x00128U, 0x00129U, 0x0012AU, + 0x24104U, 0x09400U, 0x400C0U, 0x02810U, 0x24100U, 0x00130U, 0x08082U, 0x08081U, 0x08080U, 0x31001U, 0x31000U, 0x02808U, 0x08084U, + 0x02806U, 0x0808AU, 0x02804U, 0x08088U, 0x02802U, 0x02803U, 0x02800U, 0x02801U, 0x00140U, 0x00141U, 0x00142U, 0x02408U, 0x00144U, + 0x00145U, 0x10220U, 0x10221U, 0x00148U, 0x02402U, 0x02401U, 0x02400U, 0x400A1U, 0x400A0U, 0x02405U, 0x02404U, 0x00150U, 0x00151U, + 0x00152U, 0x02418U, 0x03080U, 0x03081U, 0x03082U, 0x03083U, 0x09801U, 0x09800U, 0x02411U, 0x02410U, 0x48102U, 0x09804U, 0x48100U, + 0x48101U, 0x00160U, 0x00161U, 0x10204U, 0x10205U, 0x10202U, 0x40088U, 0x10200U, 0x10201U, 0x40085U, 0x40084U, 0x02421U, 0x02420U, + 0x40081U, 0x40080U, 0x10208U, 0x40082U, 0x41402U, 0x080C2U, 0x41400U, 0x080C0U, 0x00D01U, 0x00D00U, 0x10210U, 0x10211U, 0x40095U, + 0x40094U, 0x02844U, 0x080C8U, 0x40091U, 0x40090U, 0x02840U, 0x02841U, 0x00180U, 0x00181U, 0x00182U, 0x08030U, 0x00184U, 0x14400U, + 0x22201U, 0x22200U, 0x00188U, 0x00189U, 0x0018AU, 0x08038U, 0x40061U, 0x40060U, 0x40063U, 0x40062U, 0x00190U, 0x08022U, 0x08021U, + 0x08020U, 0x03040U, 0x03041U, 0x08025U, 0x08024U, 0x40C00U, 0x40C01U, 0x08029U, 0x08028U, 0x2C000U, 0x2C001U, 0x01501U, 0x01500U, + 0x001A0U, 0x08012U, 0x08011U, 0x08010U, 0x40049U, 0x40048U, 0x08015U, 0x08014U, 0x06200U, 0x40044U, 0x30400U, 0x08018U, 0x40041U, + 0x40040U, 0x40043U, 0x40042U, 0x08003U, 0x08002U, 0x08001U, 0x08000U, 0x08007U, 0x08006U, 0x08005U, 0x08004U, 0x0800BU, 0x0800AU, + 0x08009U, 0x08008U, 0x40051U, 0x40050U, 0x02880U, 0x0800CU, 0x001C0U, 0x001C1U, 0x64000U, 0x64001U, 0x03010U, 0x40028U, 0x08C00U, + 0x08C01U, 0x40025U, 0x40024U, 0x02481U, 0x02480U, 0x40021U, 0x40020U, 0x40023U, 0x40022U, 0x03004U, 0x03005U, 0x08061U, 0x08060U, + 0x03000U, 0x03001U, 0x03002U, 0x03003U, 0x0300CU, 0x40034U, 0x30805U, 0x30804U, 0x03008U, 0x40030U, 0x30801U, 0x30800U, 0x4000DU, + 0x4000CU, 0x08051U, 0x08050U, 0x40009U, 0x40008U, 0x10280U, 0x4000AU, 0x40005U, 0x40004U, 0x01900U, 0x40006U, 0x40001U, 0x40000U, + 0x40003U, 0x40002U, 0x14800U, 0x08042U, 0x08041U, 0x08040U, 0x03020U, 0x40018U, 0x08045U, 0x08044U, 0x40015U, 0x40014U, 0x08049U, + 0x08048U, 0x40011U, 0x40010U, 0x40013U, 0x40012U, 0x00200U, 0x00201U, 0x00202U, 0x00203U, 0x00204U, 0x00205U, 0x00206U, 0x00207U, + 0x00208U, 0x00209U, 0x0020AU, 0x50080U, 0x0020CU, 0x0020DU, 0x0020EU, 0x50084U, 0x00210U, 0x00211U, 0x00212U, 0x21040U, 0x00214U, + 0x00215U, 0x04880U, 0x04881U, 0x00218U, 0x00219U, 0x0E001U, 0x0E000U, 0x0021CU, 0x0021DU, 0x04888U, 0x0E004U, 0x00220U, 0x00221U, + 0x00222U, 0x00223U, 0x00224U, 0x00225U, 0x10140U, 0x10141U, 0x00228U, 0x00229U, 0x0022AU, 0x24204U, 0x12401U, 0x12400U, 0x24201U, + 0x24200U, 0x00230U, 0x00231U, 0x00232U, 0x21060U, 0x2A000U, 0x2A001U, 0x2A002U, 0x2A003U, 0x20881U, 0x20880U, 0x20883U, 0x20882U, + 0x05040U, 0x05041U, 0x05042U, 0x24210U, 0x00240U, 0x00241U, 0x00242U, 0x21010U, 0x00244U, 0x46000U, 0x10120U, 0x10121U, 0x00248U, + 0x00249U, 0x0024AU, 0x21018U, 0x20480U, 0x20481U, 0x20482U, 0x20483U, 0x00250U, 0x21002U, 0x21001U, 0x21000U, 0x18081U, 0x18080U, + 0x21005U, 0x21004U, 0x12800U, 0x12801U, 0x21009U, 0x21008U, 0x05020U, 0x05021U, 0x48200U, 0x48201U, 0x00260U, 0x00261U, 0x10104U, + 0x04480U, 0x10102U, 0x10103U, 0x10100U, 0x10101U, 0x62002U, 0x62003U, 0x62000U, 0x62001U, 0x05010U, 0x05011U, 0x10108U, 0x10109U, + 0x0500CU, 0x21022U, 0x21021U, 0x21020U, 0x05008U, 0x00E00U, 0x10110U, 0x10111U, 0x05004U, 0x05005U, 0x05006U, 0x21028U, 0x05000U, + 0x05001U, 0x05002U, 0x05003U, 0x00280U, 0x00281U, 0x00282U, 0x50008U, 0x00284U, 0x00285U, 0x04810U, 0x22100U, 0x00288U, 0x50002U, + 0x50001U, 0x50000U, 0x20440U, 0x20441U, 0x50005U, 0x50004U, 0x00290U, 0x00291U, 0x04804U, 0x04805U, 0x04802U, 0x18040U, 0x04800U, + 0x04801U, 0x20821U, 0x20820U, 0x50011U, 0x50010U, 0x0480AU, 0x01602U, 0x04808U, 0x01600U, 0x002A0U, 0x002A1U, 0x04441U, 0x04440U, + 0x002A4U, 0x002A5U, 0x04830U, 0x04444U, 0x06100U, 0x20810U, 0x50021U, 0x50020U, 0x06104U, 0x20814U, 0x50025U, 0x50024U, 0x20809U, + 0x20808U, 0x13000U, 0x08300U, 0x04822U, 0x2080CU, 0x04820U, 0x04821U, 0x20801U, 0x20800U, 0x20803U, 0x20802U, 0x20805U, 0x20804U, + 0x04828U, 0x20806U, 0x002C0U, 0x002C1U, 0x04421U, 0x04420U, 0x20408U, 0x18010U, 0x2040AU, 0x18012U, 0x20404U, 0x20405U, 0x50041U, + 0x50040U, 0x20400U, 0x20401U, 0x20402U, 0x20403U, 0x18005U, 0x18004U, 0x21081U, 0x21080U, 0x18001U, 0x18000U, 0x04840U, 0x18002U, + 0x20414U, 0x1800CU, 0x21089U, 0x21088U, 0x20410U, 0x18008U, 0x20412U, 0x1800AU, 0x04403U, 0x04402U, 0x04401U, 0x04400U, 0x10182U, + 0x04406U, 0x10180U, 0x04404U, 0x01A02U, 0x0440AU, 0x01A00U, 0x04408U, 0x20420U, 0x40300U, 0x20422U, 0x40302U, 0x04413U, 0x04412U, + 0x04411U, 0x04410U, 0x18021U, 0x18020U, 0x10190U, 0x18022U, 0x20841U, 0x20840U, 0x01A10U, 0x20842U, 0x05080U, 0x05081U, 0x05082U, + 0x05083U, 0x00300U, 0x00301U, 0x00302U, 0x00303U, 0x00304U, 0x00305U, 0x10060U, 0x22080U, 0x00308U, 0x00309U, 0x28800U, 0x28801U, + 0x44402U, 0x44403U, 0x44400U, 0x44401U, 0x00310U, 0x00311U, 0x10C01U, 0x10C00U, 0x00314U, 0x00315U, 0x10070U, 0x10C04U, 0x00318U, + 0x00319U, 0x28810U, 0x10C08U, 0x44412U, 0x00000U, 0x44410U, 0x44411U, 0x00320U, 0x60400U, 0x10044U, 0x10045U, 0x10042U, 0x0C800U, + 0x10040U, 0x10041U, 0x06080U, 0x06081U, 0x06082U, 0x06083U, 0x1004AU, 0x0C808U, 0x10048U, 0x10049U, 0x58008U, 0x08282U, 0x08281U, + 0x08280U, 0x10052U, 0x0C810U, 0x10050U, 0x10051U, 0x58000U, 0x58001U, 0x58002U, 0x08288U, 0x02A02U, 0x02A03U, 0x02A00U, 0x02A01U, + 0x00340U, 0x00341U, 0x10024U, 0x10025U, 0x10022U, 0x10023U, 0x10020U, 0x10021U, 0x34001U, 0x34000U, 0x02601U, 0x02600U, 0x1002AU, + 0x34004U, 0x10028U, 0x10029U, 0x0C400U, 0x0C401U, 0x21101U, 0x21100U, 0x60800U, 0x60801U, 0x10030U, 0x10031U, 0x0C408U, 0x34010U, + 0x21109U, 0x21108U, 0x60808U, 0x60809U, 0x10038U, 0x28420U, 0x10006U, 0x10007U, 0x10004U, 0x10005U, 0x10002U, 0x10003U, 0x10000U, + 0x10001U, 0x1000EU, 0x40284U, 0x1000CU, 0x1000DU, 0x1000AU, 0x40280U, 0x10008U, 0x10009U, 0x10016U, 0x10017U, 0x10014U, 0x10015U, + 0x10012U, 0x10013U, 0x10010U, 0x10011U, 0x05104U, 0x44802U, 0x44801U, 0x44800U, 0x05100U, 0x05101U, 0x10018U, 0x28400U, 0x00380U, + 0x00381U, 0x22005U, 0x22004U, 0x22003U, 0x22002U, 0x22001U, 0x22000U, 0x06020U, 0x06021U, 0x50101U, 0x50100U, 0x11800U, 0x11801U, + 0x22009U, 0x22008U, 0x45001U, 0x45000U, 0x08221U, 0x08220U, 0x04902U, 0x22012U, 0x04900U, 0x22010U, 0x06030U, 0x45008U, 0x08229U, + 0x08228U, 0x11810U, 0x11811U, 0x04908U, 0x22018U, 0x06008U, 0x06009U, 0x08211U, 0x08210U, 0x100C2U, 0x22022U, 0x100C0U, 0x22020U, + 0x06000U, 0x06001U, 0x06002U, 0x06003U, 0x06004U, 0x40240U, 0x06006U, 0x40242U, 0x08203U, 0x08202U, 0x08201U, 0x08200U, 0x08207U, + 0x08206U, 0x08205U, 0x08204U, 0x06010U, 0x20900U, 0x08209U, 0x08208U, 0x61002U, 0x20904U, 0x61000U, 0x61001U, 0x29020U, 0x29021U, + 0x100A4U, 0x22044U, 0x100A2U, 0x22042U, 0x100A0U, 0x22040U, 0x20504U, 0x40224U, 0x0D005U, 0x0D004U, 0x20500U, 0x40220U, 0x0D001U, + 0x0D000U, 0x03204U, 0x18104U, 0x08261U, 0x08260U, 0x03200U, 0x18100U, 0x03202U, 0x18102U, 0x11421U, 0x11420U, 0x00000U, 0x11422U, + 0x03208U, 0x18108U, 0x0D011U, 0x0D010U, 0x29000U, 0x29001U, 0x10084U, 0x04500U, 0x10082U, 0x40208U, 0x10080U, 0x10081U, 0x06040U, + 0x40204U, 0x06042U, 0x40206U, 0x40201U, 0x40200U, 0x10088U, 0x40202U, 0x29010U, 0x08242U, 0x08241U, 0x08240U, 0x10092U, 0x40218U, + 0x10090U, 0x10091U, 0x11401U, 0x11400U, 0x11403U, 0x11402U, 0x40211U, 0x40210U, 0x10098U, 0x40212U, 0x00400U, 0x00401U, 0x00402U, + 0x00403U, 0x00404U, 0x00405U, 0x00406U, 0x00407U, 0x00408U, 0x00409U, 0x0040AU, 0x02140U, 0x0040CU, 0x0040DU, 0x01091U, 0x01090U, + 0x00410U, 0x00411U, 0x00412U, 0x00413U, 0x00414U, 0x00860U, 0x01089U, 0x01088U, 0x00418U, 0x38000U, 0x01085U, 0x01084U, 0x01083U, + 0x01082U, 0x01081U, 0x01080U, 0x00420U, 0x00421U, 0x00422U, 0x00423U, 0x00424U, 0x00850U, 0x42080U, 0x42081U, 0x00428U, 0x00429U, + 0x48801U, 0x48800U, 0x09100U, 0x12200U, 0x24401U, 0x24400U, 0x00430U, 0x00844U, 0x00432U, 0x00846U, 0x00841U, 0x00840U, 0x1C000U, + 0x00842U, 0x00438U, 0x0084CU, 0x010A5U, 0x010A4U, 0x00849U, 0x00848U, 0x010A1U, 0x010A0U, 0x00440U, 0x00441U, 0x00442U, 0x02108U, + 0x00444U, 0x00830U, 0x70001U, 0x70000U, 0x00448U, 0x02102U, 0x02101U, 0x02100U, 0x20280U, 0x20281U, 0x02105U, 0x02104U, 0x00450U, + 0x00824U, 0x00452U, 0x00826U, 0x00821U, 0x00820U, 0x00823U, 0x00822U, 0x24802U, 0x02112U, 0x24800U, 0x02110U, 0x00829U, 0x00828U, + 0x48400U, 0x010C0U, 0x00460U, 0x00814U, 0x04281U, 0x04280U, 0x00811U, 0x00810U, 0x00813U, 0x00812U, 0x54000U, 0x54001U, 0x02121U, + 0x02120U, 0x00819U, 0x00818U, 0x0081BU, 0x0081AU, 0x00805U, 0x00804U, 0x41100U, 0x00806U, 0x00801U, 0x00800U, 0x00803U, 0x00802U, + 0x0A080U, 0x0080CU, 0x0A082U, 0x0080EU, 0x00809U, 0x00808U, 0x0080BU, 0x0080AU, 0x00480U, 0x00481U, 0x00482U, 0x00483U, 0x00484U, + 0x14100U, 0x42020U, 0x01018U, 0x00488U, 0x00489U, 0x01015U, 0x01014U, 0x20240U, 0x01012U, 0x01011U, 0x01010U, 0x00490U, 0x00491U, + 0x0100DU, 0x0100CU, 0x0100BU, 0x0100AU, 0x01009U, 0x01008U, 0x40900U, 0x01006U, 0x01005U, 0x01004U, 0x01003U, 0x01002U, 0x01001U, + 0x01000U, 0x004A0U, 0x004A1U, 0x42004U, 0x04240U, 0x42002U, 0x42003U, 0x42000U, 0x42001U, 0x30102U, 0x30103U, 0x30100U, 0x30101U, + 0x4200AU, 0x01032U, 0x42008U, 0x01030U, 0x25000U, 0x25001U, 0x08501U, 0x08500U, 0x008C1U, 0x008C0U, 0x42010U, 0x01028U, 0x0A040U, + 0x0A041U, 0x01025U, 0x01024U, 0x01023U, 0x01022U, 0x01021U, 0x01020U, 0x004C0U, 0x49000U, 0x04221U, 0x04220U, 0x20208U, 0x20209U, + 0x08900U, 0x08901U, 0x20204U, 0x20205U, 0x02181U, 0x02180U, 0x20200U, 0x20201U, 0x20202U, 0x01050U, 0x0A028U, 0x008A4U, 0x0104DU, + 0x0104CU, 0x008A1U, 0x008A0U, 0x01049U, 0x01048U, 0x0A020U, 0x0A021U, 0x01045U, 0x01044U, 0x20210U, 0x01042U, 0x01041U, 0x01040U, + 0x04203U, 0x04202U, 0x04201U, 0x04200U, 0x00891U, 0x00890U, 0x42040U, 0x04204U, 0x0A010U, 0x0A011U, 0x01C00U, 0x04208U, 0x20220U, + 0x40500U, 0x20222U, 0x40502U, 0x0A008U, 0x00884U, 0x04211U, 0x04210U, 0x00881U, 0x00880U, 0x00883U, 0x00882U, 0x0A000U, 0x0A001U, + 0x0A002U, 0x0A003U, 0x0A004U, 0x00888U, 0x01061U, 0x01060U, 0x00500U, 0x00501U, 0x00502U, 0x02048U, 0x00504U, 0x14080U, 0x00506U, + 0x14082U, 0x00508U, 0x02042U, 0x02041U, 0x02040U, 0x09020U, 0x09021U, 0x44200U, 0x02044U, 0x00510U, 0x00511U, 0x10A01U, 0x10A00U, + 0x4A001U, 0x4A000U, 0x4A003U, 0x4A002U, 0x40880U, 0x40881U, 0x02051U, 0x02050U, 0x40884U, 0x01182U, 0x01181U, 0x01180U, 0x00520U, + 0x60200U, 0x00522U, 0x60202U, 0x09008U, 0x09009U, 0x0900AU, 0x0900BU, 0x09004U, 0x09005U, 0x30080U, 0x02060U, 0x09000U, 0x09001U, + 0x09002U, 0x09003U, 0x41042U, 0x08482U, 0x41040U, 0x08480U, 0x00941U, 0x00940U, 0x41044U, 0x00942U, 0x09014U, 0x09015U, 0x02C04U, + 0x08488U, 0x09010U, 0x09011U, 0x02C00U, 0x02C01U, 0x00540U, 0x0200AU, 0x02009U, 0x02008U, 0x08882U, 0x0200EU, 0x08880U, 0x0200CU, + 0x02003U, 0x02002U, 0x02001U, 0x02000U, 0x02007U, 0x02006U, 0x02005U, 0x02004U, 0x0C200U, 0x0C201U, 0x41020U, 0x02018U, 0x00921U, + 0x00920U, 0x41024U, 0x00922U, 0x02013U, 0x02012U, 0x02011U, 0x02010U, 0x02017U, 0x02016U, 0x02015U, 0x02014U, 0x41012U, 0x0202AU, + 0x41010U, 0x02028U, 0x26000U, 0x00910U, 0x10600U, 0x10601U, 0x02023U, 0x02022U, 0x02021U, 0x02020U, 0x09040U, 0x40480U, 0x02025U, + 0x02024U, 0x41002U, 0x00904U, 0x41000U, 0x41001U, 0x00901U, 0x00900U, 0x41004U, 0x00902U, 0x4100AU, 0x02032U, 0x41008U, 0x02030U, + 0x00909U, 0x00908U, 0x28201U, 0x28200U, 0x00580U, 0x14004U, 0x00582U, 0x14006U, 0x14001U, 0x14000U, 0x08840U, 0x14002U, 0x40810U, + 0x40811U, 0x30020U, 0x020C0U, 0x14009U, 0x14008U, 0x01111U, 0x01110U, 0x40808U, 0x40809U, 0x08421U, 0x08420U, 0x14011U, 0x14010U, + 0x01109U, 0x01108U, 0x40800U, 0x40801U, 0x40802U, 0x01104U, 0x40804U, 0x01102U, 0x01101U, 0x01100U, 0x03801U, 0x03800U, 0x30008U, + 0x08410U, 0x14021U, 0x14020U, 0x42100U, 0x42101U, 0x30002U, 0x30003U, 0x30000U, 0x30001U, 0x09080U, 0x40440U, 0x30004U, 0x30005U, + 0x08403U, 0x08402U, 0x08401U, 0x08400U, 0x08407U, 0x08406U, 0x08405U, 0x08404U, 0x40820U, 0x40821U, 0x30010U, 0x08408U, 0x40824U, + 0x01122U, 0x01121U, 0x01120U, 0x08806U, 0x0208AU, 0x08804U, 0x02088U, 0x08802U, 0x14040U, 0x08800U, 0x08801U, 0x02083U, 0x02082U, + 0x02081U, 0x02080U, 0x20300U, 0x40420U, 0x08808U, 0x02084U, 0x03404U, 0x03405U, 0x08814U, 0x02098U, 0x03400U, 0x03401U, 0x08810U, + 0x08811U, 0x40840U, 0x40841U, 0x02091U, 0x02090U, 0x40844U, 0x01142U, 0x01141U, 0x01140U, 0x04303U, 0x04302U, 0x04301U, 0x04300U, + 0x40409U, 0x40408U, 0x08820U, 0x08821U, 0x40405U, 0x40404U, 0x30040U, 0x020A0U, 0x40401U, 0x40400U, 0x40403U, 0x40402U, 0x41082U, + 0x08442U, 0x41080U, 0x08440U, 0x00981U, 0x00980U, 0x41084U, 0x00982U, 0x0A100U, 0x11200U, 0x0A102U, 0x11202U, 0x40411U, 0x40410U, + 0x40413U, 0x40412U, 0x00600U, 0x00601U, 0x00602U, 0x00603U, 0x00604U, 0x00605U, 0x00606U, 0x00607U, 0x00608U, 0x05800U, 0x0060AU, + 0x05802U, 0x200C0U, 0x12020U, 0x44100U, 0x44101U, 0x00610U, 0x00611U, 0x10901U, 0x10900U, 0x51000U, 0x51001U, 0x51002U, 0x10904U, + 0x00618U, 0x05810U, 0x01285U, 0x01284U, 0x51008U, 0x01282U, 0x01281U, 0x01280U, 0x00620U, 0x60100U, 0x040C1U, 0x040C0U, 0x12009U, + 0x12008U, 0x21800U, 0x21801U, 0x12005U, 0x12004U, 0x12007U, 0x12006U, 0x12001U, 0x12000U, 0x12003U, 0x12002U, 0x00630U, 0x00A44U, + 0x040D1U, 0x040D0U, 0x00A41U, 0x00A40U, 0x21810U, 0x00A42U, 0x12015U, 0x12014U, 0x00000U, 0x12016U, 0x12011U, 0x12010U, 0x12013U, + 0x12012U, 0x00640U, 0x00641U, 0x040A1U, 0x040A0U, 0x20088U, 0x20089U, 0x2008AU, 0x040A4U, 0x20084U, 0x20085U, 0x19000U, 0x02300U, + 0x20080U, 0x20081U, 0x20082U, 0x20083U, 0x0C100U, 0x0C101U, 0x21401U, 0x21400U, 0x00A21U, 0x00A20U, 0x00A23U, 0x00A22U, 0x20094U, + 0x20095U, 0x19010U, 0x21408U, 0x20090U, 0x20091U, 0x20092U, 0x28120U, 0x04083U, 0x04082U, 0x04081U, 0x04080U, 0x00A11U, 0x00A10U, + 0x10500U, 0x04084U, 0x200A4U, 0x0408AU, 0x04089U, 0x04088U, 0x200A0U, 0x12040U, 0x200A2U, 0x12042U, 0x00A05U, 0x00A04U, 0x04091U, + 0x04090U, 0x00A01U, 0x00A00U, 0x00A03U, 0x00A02U, 0x05404U, 0x00A0CU, 0x28105U, 0x28104U, 0x05400U, 0x00A08U, 0x28101U, 0x28100U, + 0x00680U, 0x00681U, 0x04061U, 0x04060U, 0x20048U, 0x20049U, 0x2004AU, 0x04064U, 0x20044U, 0x20045U, 0x50401U, 0x50400U, 0x20040U, + 0x20041U, 0x20042U, 0x01210U, 0x68002U, 0x68003U, 0x68000U, 0x68001U, 0x04C02U, 0x0120AU, 0x04C00U, 0x01208U, 0x20054U, 0x01206U, + 0x01205U, 0x01204U, 0x20050U, 0x01202U, 0x01201U, 0x01200U, 0x18800U, 0x04042U, 0x04041U, 0x04040U, 0x42202U, 0x04046U, 0x42200U, + 0x04044U, 0x20064U, 0x0404AU, 0x04049U, 0x04048U, 0x20060U, 0x12080U, 0x20062U, 0x12082U, 0x18810U, 0x04052U, 0x04051U, 0x04050U, + 0x4C009U, 0x4C008U, 0x42210U, 0x04054U, 0x20C01U, 0x20C00U, 0x20C03U, 0x20C02U, 0x4C001U, 0x4C000U, 0x01221U, 0x01220U, 0x2000CU, + 0x04022U, 0x04021U, 0x04020U, 0x20008U, 0x20009U, 0x2000AU, 0x04024U, 0x20004U, 0x20005U, 0x20006U, 0x04028U, 0x20000U, 0x20001U, + 0x20002U, 0x20003U, 0x2001CU, 0x04032U, 0x04031U, 0x04030U, 0x20018U, 0x18400U, 0x2001AU, 0x18402U, 0x20014U, 0x20015U, 0x20016U, + 0x01244U, 0x20010U, 0x20011U, 0x20012U, 0x01240U, 0x04003U, 0x04002U, 0x04001U, 0x04000U, 0x20028U, 0x04006U, 0x04005U, 0x04004U, + 0x20024U, 0x0400AU, 0x04009U, 0x04008U, 0x20020U, 0x20021U, 0x20022U, 0x0400CU, 0x04013U, 0x04012U, 0x04011U, 0x04010U, 0x00A81U, + 0x00A80U, 0x04015U, 0x04014U, 0x0A200U, 0x11100U, 0x04019U, 0x04018U, 0x20030U, 0x20031U, 0x50800U, 0x50801U, 0x00700U, 0x60020U, + 0x10811U, 0x10810U, 0x4400AU, 0x60024U, 0x44008U, 0x44009U, 0x44006U, 0x02242U, 0x44004U, 0x02240U, 0x44002U, 0x44003U, 0x44000U, + 0x44001U, 0x0C040U, 0x10802U, 0x10801U, 0x10800U, 0x0C044U, 0x10806U, 0x10805U, 0x10804U, 0x23000U, 0x23001U, 0x10809U, 0x10808U, + 0x44012U, 0x44013U, 0x44010U, 0x44011U, 0x60001U, 0x60000U, 0x60003U, 0x60002U, 0x60005U, 0x60004U, 0x10440U, 0x10441U, 0x60009U, + 0x60008U, 0x44024U, 0x6000AU, 0x09200U, 0x12100U, 0x44020U, 0x44021U, 0x60011U, 0x60010U, 0x10821U, 0x10820U, 0x07003U, 0x07002U, + 0x07001U, 0x07000U, 0x23020U, 0x60018U, 0x28045U, 0x28044U, 0x09210U, 0x28042U, 0x28041U, 0x28040U, 0x0C010U, 0x0C011U, 0x02209U, + 0x02208U, 0x10422U, 0x10423U, 0x10420U, 0x10421U, 0x02203U, 0x02202U, 0x02201U, 0x02200U, 0x20180U, 0x20181U, 0x44040U, 0x02204U, + 0x0C000U, 0x0C001U, 0x0C002U, 0x10840U, 0x0C004U, 0x0C005U, 0x0C006U, 0x10844U, 0x0C008U, 0x0C009U, 0x02211U, 0x02210U, 0x0C00CU, + 0x28022U, 0x28021U, 0x28020U, 0x60041U, 0x60040U, 0x10404U, 0x04180U, 0x10402U, 0x10403U, 0x10400U, 0x10401U, 0x02223U, 0x02222U, + 0x02221U, 0x02220U, 0x1040AU, 0x28012U, 0x10408U, 0x28010U, 0x0C020U, 0x0C021U, 0x41200U, 0x41201U, 0x00B01U, 0x00B00U, 0x10410U, + 0x28008U, 0x11081U, 0x11080U, 0x28005U, 0x28004U, 0x28003U, 0x28002U, 0x28001U, 0x28000U, 0x52040U, 0x14204U, 0x22405U, 0x22404U, + 0x14201U, 0x14200U, 0x22401U, 0x22400U, 0x20144U, 0x20145U, 0x44084U, 0x022C0U, 0x20140U, 0x20141U, 0x44080U, 0x44081U, 0x40A08U, + 0x10882U, 0x10881U, 0x10880U, 0x14211U, 0x14210U, 0x1A008U, 0x10884U, 0x40A00U, 0x40A01U, 0x40A02U, 0x01304U, 0x1A002U, 0x01302U, + 0x1A000U, 0x01300U, 0x60081U, 0x60080U, 0x04141U, 0x04140U, 0x60085U, 0x60084U, 0x104C0U, 0x04144U, 0x06400U, 0x06401U, 0x30200U, + 0x30201U, 0x06404U, 0x40640U, 0x30204U, 0x30205U, 0x08603U, 0x08602U, 0x08601U, 0x08600U, 0x00000U, 0x08606U, 0x08605U, 0x08604U, + 0x11041U, 0x11040U, 0x30210U, 0x11042U, 0x11045U, 0x11044U, 0x1A020U, 0x01320U, 0x52000U, 0x52001U, 0x04121U, 0x04120U, 0x20108U, + 0x20109U, 0x08A00U, 0x08A01U, 0x20104U, 0x20105U, 0x02281U, 0x02280U, 0x20100U, 0x20101U, 0x20102U, 0x20103U, 0x0C080U, 0x0C081U, + 0x0C082U, 0x04130U, 0x0C084U, 0x06808U, 0x08A10U, 0x08A11U, 0x11021U, 0x11020U, 0x11023U, 0x11022U, 0x20110U, 0x06800U, 0x20112U, + 0x06802U, 0x04103U, 0x04102U, 0x04101U, 0x04100U, 0x10482U, 0x04106U, 0x10480U, 0x04104U, 0x11011U, 0x11010U, 0x04109U, 0x04108U, + 0x20120U, 0x40600U, 0x20122U, 0x40602U, 0x11009U, 0x11008U, 0x22800U, 0x04110U, 0x1100DU, 0x1100CU, 0x22804U, 0x04114U, 0x11001U, + 0x11000U, 0x11003U, 0x11002U, 0x11005U, 0x11004U, 0x28081U, 0x28080U}; + +#define X18 0x00040000 /* vector representation of X^{18} */ +#define X11 0x00000800 /* vector representation of X^{11} */ +#define MASK8 0xfffff800 /* auxiliary vector for testing */ +#define GENPOL 0x00000c75 /* generator polinomial, g(x) */ + +unsigned int CGolay2087::getSyndrome1987(unsigned int pattern) +/* + * Compute the syndrome corresponding to the given pattern, i.e., the + * remainder after dividing the pattern (when considering it as the vector + * representation of a polynomial) by the generator polynomial, GENPOL. + * In the program this pattern has several meanings: (1) pattern = infomation + * bits, when constructing the encoding table; (2) pattern = error pattern, + * when constructing the decoding table; and (3) pattern = received vector, to + * obtain its syndrome in decoding. + */ +{ + unsigned int aux = X18; + + if (pattern >= X11) { + while (pattern & MASK8) { + while (!(aux & pattern)) + aux = aux >> 1; + + pattern ^= (aux / X11) * GENPOL; + } + } + + return pattern; +} + +unsigned char CGolay2087::decode(const unsigned char* data) +{ + assert(data != NULL); + + unsigned int code = (data[0U] << 11) + (data[1U] << 3) + (data[2U] >> 5); + unsigned int syndrome = getSyndrome1987(code); + unsigned int error_pattern = DECODING_TABLE_1987[syndrome]; + + if (error_pattern != 0x00U) + code ^= error_pattern; + + return code >> 11; +} + +void CGolay2087::encode(unsigned char* data) +{ + assert(data != NULL); + + unsigned int value = data[0U]; + + unsigned int cksum = ENCODING_TABLE_2087[value]; + + data[1U] = cksum & 0xFFU; + data[2U] = cksum >> 8; +} diff --git a/Golay2087.h b/Golay2087.h new file mode 100644 index 0000000..d54daed --- /dev/null +++ b/Golay2087.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef Golay2087_H +#define Golay2087_H + +class CGolay2087 { +public: + static void encode(unsigned char* data); + + static unsigned char decode(const unsigned char* data); + +private: + static unsigned int getSyndrome1987(unsigned int pattern); +}; + +#endif diff --git a/Golay24128.cpp b/Golay24128.cpp new file mode 100644 index 0000000..4bca5de --- /dev/null +++ b/Golay24128.cpp @@ -0,0 +1,1092 @@ +/* + * Copyright (C) 2010,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2002 by Robert H. Morelos-Zaragoza. All rights reserved. + */ + +#include "Golay24128.h" + +static const unsigned int ENCODING_TABLE_23127[] = { + 0x000000U, 0x0018EAU, 0x00293EU, 0x0031D4U, 0x004A96U, 0x00527CU, 0x0063A8U, 0x007B42U, 0x008DC6U, 0x00952CU, + 0x00A4F8U, 0x00BC12U, 0x00C750U, 0x00DFBAU, 0x00EE6EU, 0x00F684U, 0x010366U, 0x011B8CU, 0x012A58U, 0x0132B2U, + 0x0149F0U, 0x01511AU, 0x0160CEU, 0x017824U, 0x018EA0U, 0x01964AU, 0x01A79EU, 0x01BF74U, 0x01C436U, 0x01DCDCU, + 0x01ED08U, 0x01F5E2U, 0x0206CCU, 0x021E26U, 0x022FF2U, 0x023718U, 0x024C5AU, 0x0254B0U, 0x026564U, 0x027D8EU, + 0x028B0AU, 0x0293E0U, 0x02A234U, 0x02BADEU, 0x02C19CU, 0x02D976U, 0x02E8A2U, 0x02F048U, 0x0305AAU, 0x031D40U, + 0x032C94U, 0x03347EU, 0x034F3CU, 0x0357D6U, 0x036602U, 0x037EE8U, 0x03886CU, 0x039086U, 0x03A152U, 0x03B9B8U, + 0x03C2FAU, 0x03DA10U, 0x03EBC4U, 0x03F32EU, 0x040D98U, 0x041572U, 0x0424A6U, 0x043C4CU, 0x04470EU, 0x045FE4U, + 0x046E30U, 0x0476DAU, 0x04805EU, 0x0498B4U, 0x04A960U, 0x04B18AU, 0x04CAC8U, 0x04D222U, 0x04E3F6U, 0x04FB1CU, + 0x050EFEU, 0x051614U, 0x0527C0U, 0x053F2AU, 0x054468U, 0x055C82U, 0x056D56U, 0x0575BCU, 0x058338U, 0x059BD2U, + 0x05AA06U, 0x05B2ECU, 0x05C9AEU, 0x05D144U, 0x05E090U, 0x05F87AU, 0x060B54U, 0x0613BEU, 0x06226AU, 0x063A80U, + 0x0641C2U, 0x065928U, 0x0668FCU, 0x067016U, 0x068692U, 0x069E78U, 0x06AFACU, 0x06B746U, 0x06CC04U, 0x06D4EEU, + 0x06E53AU, 0x06FDD0U, 0x070832U, 0x0710D8U, 0x07210CU, 0x0739E6U, 0x0742A4U, 0x075A4EU, 0x076B9AU, 0x077370U, + 0x0785F4U, 0x079D1EU, 0x07ACCAU, 0x07B420U, 0x07CF62U, 0x07D788U, 0x07E65CU, 0x07FEB6U, 0x0803DAU, 0x081B30U, + 0x082AE4U, 0x08320EU, 0x08494CU, 0x0851A6U, 0x086072U, 0x087898U, 0x088E1CU, 0x0896F6U, 0x08A722U, 0x08BFC8U, + 0x08C48AU, 0x08DC60U, 0x08EDB4U, 0x08F55EU, 0x0900BCU, 0x091856U, 0x092982U, 0x093168U, 0x094A2AU, 0x0952C0U, + 0x096314U, 0x097BFEU, 0x098D7AU, 0x099590U, 0x09A444U, 0x09BCAEU, 0x09C7ECU, 0x09DF06U, 0x09EED2U, 0x09F638U, + 0x0A0516U, 0x0A1DFCU, 0x0A2C28U, 0x0A34C2U, 0x0A4F80U, 0x0A576AU, 0x0A66BEU, 0x0A7E54U, 0x0A88D0U, 0x0A903AU, + 0x0AA1EEU, 0x0AB904U, 0x0AC246U, 0x0ADAACU, 0x0AEB78U, 0x0AF392U, 0x0B0670U, 0x0B1E9AU, 0x0B2F4EU, 0x0B37A4U, + 0x0B4CE6U, 0x0B540CU, 0x0B65D8U, 0x0B7D32U, 0x0B8BB6U, 0x0B935CU, 0x0BA288U, 0x0BBA62U, 0x0BC120U, 0x0BD9CAU, + 0x0BE81EU, 0x0BF0F4U, 0x0C0E42U, 0x0C16A8U, 0x0C277CU, 0x0C3F96U, 0x0C44D4U, 0x0C5C3EU, 0x0C6DEAU, 0x0C7500U, + 0x0C8384U, 0x0C9B6EU, 0x0CAABAU, 0x0CB250U, 0x0CC912U, 0x0CD1F8U, 0x0CE02CU, 0x0CF8C6U, 0x0D0D24U, 0x0D15CEU, + 0x0D241AU, 0x0D3CF0U, 0x0D47B2U, 0x0D5F58U, 0x0D6E8CU, 0x0D7666U, 0x0D80E2U, 0x0D9808U, 0x0DA9DCU, 0x0DB136U, + 0x0DCA74U, 0x0DD29EU, 0x0DE34AU, 0x0DFBA0U, 0x0E088EU, 0x0E1064U, 0x0E21B0U, 0x0E395AU, 0x0E4218U, 0x0E5AF2U, + 0x0E6B26U, 0x0E73CCU, 0x0E8548U, 0x0E9DA2U, 0x0EAC76U, 0x0EB49CU, 0x0ECFDEU, 0x0ED734U, 0x0EE6E0U, 0x0EFE0AU, + 0x0F0BE8U, 0x0F1302U, 0x0F22D6U, 0x0F3A3CU, 0x0F417EU, 0x0F5994U, 0x0F6840U, 0x0F70AAU, 0x0F862EU, 0x0F9EC4U, + 0x0FAF10U, 0x0FB7FAU, 0x0FCCB8U, 0x0FD452U, 0x0FE586U, 0x0FFD6CU, 0x1007B4U, 0x101F5EU, 0x102E8AU, 0x103660U, + 0x104D22U, 0x1055C8U, 0x10641CU, 0x107CF6U, 0x108A72U, 0x109298U, 0x10A34CU, 0x10BBA6U, 0x10C0E4U, 0x10D80EU, + 0x10E9DAU, 0x10F130U, 0x1104D2U, 0x111C38U, 0x112DECU, 0x113506U, 0x114E44U, 0x1156AEU, 0x11677AU, 0x117F90U, + 0x118914U, 0x1191FEU, 0x11A02AU, 0x11B8C0U, 0x11C382U, 0x11DB68U, 0x11EABCU, 0x11F256U, 0x120178U, 0x121992U, + 0x122846U, 0x1230ACU, 0x124BEEU, 0x125304U, 0x1262D0U, 0x127A3AU, 0x128CBEU, 0x129454U, 0x12A580U, 0x12BD6AU, + 0x12C628U, 0x12DEC2U, 0x12EF16U, 0x12F7FCU, 0x13021EU, 0x131AF4U, 0x132B20U, 0x1333CAU, 0x134888U, 0x135062U, + 0x1361B6U, 0x13795CU, 0x138FD8U, 0x139732U, 0x13A6E6U, 0x13BE0CU, 0x13C54EU, 0x13DDA4U, 0x13EC70U, 0x13F49AU, + 0x140A2CU, 0x1412C6U, 0x142312U, 0x143BF8U, 0x1440BAU, 0x145850U, 0x146984U, 0x14716EU, 0x1487EAU, 0x149F00U, + 0x14AED4U, 0x14B63EU, 0x14CD7CU, 0x14D596U, 0x14E442U, 0x14FCA8U, 0x15094AU, 0x1511A0U, 0x152074U, 0x15389EU, + 0x1543DCU, 0x155B36U, 0x156AE2U, 0x157208U, 0x15848CU, 0x159C66U, 0x15ADB2U, 0x15B558U, 0x15CE1AU, 0x15D6F0U, + 0x15E724U, 0x15FFCEU, 0x160CE0U, 0x16140AU, 0x1625DEU, 0x163D34U, 0x164676U, 0x165E9CU, 0x166F48U, 0x1677A2U, + 0x168126U, 0x1699CCU, 0x16A818U, 0x16B0F2U, 0x16CBB0U, 0x16D35AU, 0x16E28EU, 0x16FA64U, 0x170F86U, 0x17176CU, + 0x1726B8U, 0x173E52U, 0x174510U, 0x175DFAU, 0x176C2EU, 0x1774C4U, 0x178240U, 0x179AAAU, 0x17AB7EU, 0x17B394U, + 0x17C8D6U, 0x17D03CU, 0x17E1E8U, 0x17F902U, 0x18046EU, 0x181C84U, 0x182D50U, 0x1835BAU, 0x184EF8U, 0x185612U, + 0x1867C6U, 0x187F2CU, 0x1889A8U, 0x189142U, 0x18A096U, 0x18B87CU, 0x18C33EU, 0x18DBD4U, 0x18EA00U, 0x18F2EAU, + 0x190708U, 0x191FE2U, 0x192E36U, 0x1936DCU, 0x194D9EU, 0x195574U, 0x1964A0U, 0x197C4AU, 0x198ACEU, 0x199224U, + 0x19A3F0U, 0x19BB1AU, 0x19C058U, 0x19D8B2U, 0x19E966U, 0x19F18CU, 0x1A02A2U, 0x1A1A48U, 0x1A2B9CU, 0x1A3376U, + 0x1A4834U, 0x1A50DEU, 0x1A610AU, 0x1A79E0U, 0x1A8F64U, 0x1A978EU, 0x1AA65AU, 0x1ABEB0U, 0x1AC5F2U, 0x1ADD18U, + 0x1AECCCU, 0x1AF426U, 0x1B01C4U, 0x1B192EU, 0x1B28FAU, 0x1B3010U, 0x1B4B52U, 0x1B53B8U, 0x1B626CU, 0x1B7A86U, + 0x1B8C02U, 0x1B94E8U, 0x1BA53CU, 0x1BBDD6U, 0x1BC694U, 0x1BDE7EU, 0x1BEFAAU, 0x1BF740U, 0x1C09F6U, 0x1C111CU, + 0x1C20C8U, 0x1C3822U, 0x1C4360U, 0x1C5B8AU, 0x1C6A5EU, 0x1C72B4U, 0x1C8430U, 0x1C9CDAU, 0x1CAD0EU, 0x1CB5E4U, + 0x1CCEA6U, 0x1CD64CU, 0x1CE798U, 0x1CFF72U, 0x1D0A90U, 0x1D127AU, 0x1D23AEU, 0x1D3B44U, 0x1D4006U, 0x1D58ECU, + 0x1D6938U, 0x1D71D2U, 0x1D8756U, 0x1D9FBCU, 0x1DAE68U, 0x1DB682U, 0x1DCDC0U, 0x1DD52AU, 0x1DE4FEU, 0x1DFC14U, + 0x1E0F3AU, 0x1E17D0U, 0x1E2604U, 0x1E3EEEU, 0x1E45ACU, 0x1E5D46U, 0x1E6C92U, 0x1E7478U, 0x1E82FCU, 0x1E9A16U, + 0x1EABC2U, 0x1EB328U, 0x1EC86AU, 0x1ED080U, 0x1EE154U, 0x1EF9BEU, 0x1F0C5CU, 0x1F14B6U, 0x1F2562U, 0x1F3D88U, + 0x1F46CAU, 0x1F5E20U, 0x1F6FF4U, 0x1F771EU, 0x1F819AU, 0x1F9970U, 0x1FA8A4U, 0x1FB04EU, 0x1FCB0CU, 0x1FD3E6U, + 0x1FE232U, 0x1FFAD8U, 0x200F68U, 0x201782U, 0x202656U, 0x203EBCU, 0x2045FEU, 0x205D14U, 0x206CC0U, 0x20742AU, + 0x2082AEU, 0x209A44U, 0x20AB90U, 0x20B37AU, 0x20C838U, 0x20D0D2U, 0x20E106U, 0x20F9ECU, 0x210C0EU, 0x2114E4U, + 0x212530U, 0x213DDAU, 0x214698U, 0x215E72U, 0x216FA6U, 0x21774CU, 0x2181C8U, 0x219922U, 0x21A8F6U, 0x21B01CU, + 0x21CB5EU, 0x21D3B4U, 0x21E260U, 0x21FA8AU, 0x2209A4U, 0x22114EU, 0x22209AU, 0x223870U, 0x224332U, 0x225BD8U, + 0x226A0CU, 0x2272E6U, 0x228462U, 0x229C88U, 0x22AD5CU, 0x22B5B6U, 0x22CEF4U, 0x22D61EU, 0x22E7CAU, 0x22FF20U, + 0x230AC2U, 0x231228U, 0x2323FCU, 0x233B16U, 0x234054U, 0x2358BEU, 0x23696AU, 0x237180U, 0x238704U, 0x239FEEU, + 0x23AE3AU, 0x23B6D0U, 0x23CD92U, 0x23D578U, 0x23E4ACU, 0x23FC46U, 0x2402F0U, 0x241A1AU, 0x242BCEU, 0x243324U, + 0x244866U, 0x24508CU, 0x246158U, 0x2479B2U, 0x248F36U, 0x2497DCU, 0x24A608U, 0x24BEE2U, 0x24C5A0U, 0x24DD4AU, + 0x24EC9EU, 0x24F474U, 0x250196U, 0x25197CU, 0x2528A8U, 0x253042U, 0x254B00U, 0x2553EAU, 0x25623EU, 0x257AD4U, + 0x258C50U, 0x2594BAU, 0x25A56EU, 0x25BD84U, 0x25C6C6U, 0x25DE2CU, 0x25EFF8U, 0x25F712U, 0x26043CU, 0x261CD6U, + 0x262D02U, 0x2635E8U, 0x264EAAU, 0x265640U, 0x266794U, 0x267F7EU, 0x2689FAU, 0x269110U, 0x26A0C4U, 0x26B82EU, + 0x26C36CU, 0x26DB86U, 0x26EA52U, 0x26F2B8U, 0x27075AU, 0x271FB0U, 0x272E64U, 0x27368EU, 0x274DCCU, 0x275526U, + 0x2764F2U, 0x277C18U, 0x278A9CU, 0x279276U, 0x27A3A2U, 0x27BB48U, 0x27C00AU, 0x27D8E0U, 0x27E934U, 0x27F1DEU, + 0x280CB2U, 0x281458U, 0x28258CU, 0x283D66U, 0x284624U, 0x285ECEU, 0x286F1AU, 0x2877F0U, 0x288174U, 0x28999EU, + 0x28A84AU, 0x28B0A0U, 0x28CBE2U, 0x28D308U, 0x28E2DCU, 0x28FA36U, 0x290FD4U, 0x29173EU, 0x2926EAU, 0x293E00U, + 0x294542U, 0x295DA8U, 0x296C7CU, 0x297496U, 0x298212U, 0x299AF8U, 0x29AB2CU, 0x29B3C6U, 0x29C884U, 0x29D06EU, + 0x29E1BAU, 0x29F950U, 0x2A0A7EU, 0x2A1294U, 0x2A2340U, 0x2A3BAAU, 0x2A40E8U, 0x2A5802U, 0x2A69D6U, 0x2A713CU, + 0x2A87B8U, 0x2A9F52U, 0x2AAE86U, 0x2AB66CU, 0x2ACD2EU, 0x2AD5C4U, 0x2AE410U, 0x2AFCFAU, 0x2B0918U, 0x2B11F2U, + 0x2B2026U, 0x2B38CCU, 0x2B438EU, 0x2B5B64U, 0x2B6AB0U, 0x2B725AU, 0x2B84DEU, 0x2B9C34U, 0x2BADE0U, 0x2BB50AU, + 0x2BCE48U, 0x2BD6A2U, 0x2BE776U, 0x2BFF9CU, 0x2C012AU, 0x2C19C0U, 0x2C2814U, 0x2C30FEU, 0x2C4BBCU, 0x2C5356U, + 0x2C6282U, 0x2C7A68U, 0x2C8CECU, 0x2C9406U, 0x2CA5D2U, 0x2CBD38U, 0x2CC67AU, 0x2CDE90U, 0x2CEF44U, 0x2CF7AEU, + 0x2D024CU, 0x2D1AA6U, 0x2D2B72U, 0x2D3398U, 0x2D48DAU, 0x2D5030U, 0x2D61E4U, 0x2D790EU, 0x2D8F8AU, 0x2D9760U, + 0x2DA6B4U, 0x2DBE5EU, 0x2DC51CU, 0x2DDDF6U, 0x2DEC22U, 0x2DF4C8U, 0x2E07E6U, 0x2E1F0CU, 0x2E2ED8U, 0x2E3632U, + 0x2E4D70U, 0x2E559AU, 0x2E644EU, 0x2E7CA4U, 0x2E8A20U, 0x2E92CAU, 0x2EA31EU, 0x2EBBF4U, 0x2EC0B6U, 0x2ED85CU, + 0x2EE988U, 0x2EF162U, 0x2F0480U, 0x2F1C6AU, 0x2F2DBEU, 0x2F3554U, 0x2F4E16U, 0x2F56FCU, 0x2F6728U, 0x2F7FC2U, + 0x2F8946U, 0x2F91ACU, 0x2FA078U, 0x2FB892U, 0x2FC3D0U, 0x2FDB3AU, 0x2FEAEEU, 0x2FF204U, 0x3008DCU, 0x301036U, + 0x3021E2U, 0x303908U, 0x30424AU, 0x305AA0U, 0x306B74U, 0x30739EU, 0x30851AU, 0x309DF0U, 0x30AC24U, 0x30B4CEU, + 0x30CF8CU, 0x30D766U, 0x30E6B2U, 0x30FE58U, 0x310BBAU, 0x311350U, 0x312284U, 0x313A6EU, 0x31412CU, 0x3159C6U, + 0x316812U, 0x3170F8U, 0x31867CU, 0x319E96U, 0x31AF42U, 0x31B7A8U, 0x31CCEAU, 0x31D400U, 0x31E5D4U, 0x31FD3EU, + 0x320E10U, 0x3216FAU, 0x32272EU, 0x323FC4U, 0x324486U, 0x325C6CU, 0x326DB8U, 0x327552U, 0x3283D6U, 0x329B3CU, + 0x32AAE8U, 0x32B202U, 0x32C940U, 0x32D1AAU, 0x32E07EU, 0x32F894U, 0x330D76U, 0x33159CU, 0x332448U, 0x333CA2U, + 0x3347E0U, 0x335F0AU, 0x336EDEU, 0x337634U, 0x3380B0U, 0x33985AU, 0x33A98EU, 0x33B164U, 0x33CA26U, 0x33D2CCU, + 0x33E318U, 0x33FBF2U, 0x340544U, 0x341DAEU, 0x342C7AU, 0x343490U, 0x344FD2U, 0x345738U, 0x3466ECU, 0x347E06U, + 0x348882U, 0x349068U, 0x34A1BCU, 0x34B956U, 0x34C214U, 0x34DAFEU, 0x34EB2AU, 0x34F3C0U, 0x350622U, 0x351EC8U, + 0x352F1CU, 0x3537F6U, 0x354CB4U, 0x35545EU, 0x35658AU, 0x357D60U, 0x358BE4U, 0x35930EU, 0x35A2DAU, 0x35BA30U, + 0x35C172U, 0x35D998U, 0x35E84CU, 0x35F0A6U, 0x360388U, 0x361B62U, 0x362AB6U, 0x36325CU, 0x36491EU, 0x3651F4U, + 0x366020U, 0x3678CAU, 0x368E4EU, 0x3696A4U, 0x36A770U, 0x36BF9AU, 0x36C4D8U, 0x36DC32U, 0x36EDE6U, 0x36F50CU, + 0x3700EEU, 0x371804U, 0x3729D0U, 0x37313AU, 0x374A78U, 0x375292U, 0x376346U, 0x377BACU, 0x378D28U, 0x3795C2U, + 0x37A416U, 0x37BCFCU, 0x37C7BEU, 0x37DF54U, 0x37EE80U, 0x37F66AU, 0x380B06U, 0x3813ECU, 0x382238U, 0x383AD2U, + 0x384190U, 0x38597AU, 0x3868AEU, 0x387044U, 0x3886C0U, 0x389E2AU, 0x38AFFEU, 0x38B714U, 0x38CC56U, 0x38D4BCU, + 0x38E568U, 0x38FD82U, 0x390860U, 0x39108AU, 0x39215EU, 0x3939B4U, 0x3942F6U, 0x395A1CU, 0x396BC8U, 0x397322U, + 0x3985A6U, 0x399D4CU, 0x39AC98U, 0x39B472U, 0x39CF30U, 0x39D7DAU, 0x39E60EU, 0x39FEE4U, 0x3A0DCAU, 0x3A1520U, + 0x3A24F4U, 0x3A3C1EU, 0x3A475CU, 0x3A5FB6U, 0x3A6E62U, 0x3A7688U, 0x3A800CU, 0x3A98E6U, 0x3AA932U, 0x3AB1D8U, + 0x3ACA9AU, 0x3AD270U, 0x3AE3A4U, 0x3AFB4EU, 0x3B0EACU, 0x3B1646U, 0x3B2792U, 0x3B3F78U, 0x3B443AU, 0x3B5CD0U, + 0x3B6D04U, 0x3B75EEU, 0x3B836AU, 0x3B9B80U, 0x3BAA54U, 0x3BB2BEU, 0x3BC9FCU, 0x3BD116U, 0x3BE0C2U, 0x3BF828U, + 0x3C069EU, 0x3C1E74U, 0x3C2FA0U, 0x3C374AU, 0x3C4C08U, 0x3C54E2U, 0x3C6536U, 0x3C7DDCU, 0x3C8B58U, 0x3C93B2U, + 0x3CA266U, 0x3CBA8CU, 0x3CC1CEU, 0x3CD924U, 0x3CE8F0U, 0x3CF01AU, 0x3D05F8U, 0x3D1D12U, 0x3D2CC6U, 0x3D342CU, + 0x3D4F6EU, 0x3D5784U, 0x3D6650U, 0x3D7EBAU, 0x3D883EU, 0x3D90D4U, 0x3DA100U, 0x3DB9EAU, 0x3DC2A8U, 0x3DDA42U, + 0x3DEB96U, 0x3DF37CU, 0x3E0052U, 0x3E18B8U, 0x3E296CU, 0x3E3186U, 0x3E4AC4U, 0x3E522EU, 0x3E63FAU, 0x3E7B10U, + 0x3E8D94U, 0x3E957EU, 0x3EA4AAU, 0x3EBC40U, 0x3EC702U, 0x3EDFE8U, 0x3EEE3CU, 0x3EF6D6U, 0x3F0334U, 0x3F1BDEU, + 0x3F2A0AU, 0x3F32E0U, 0x3F49A2U, 0x3F5148U, 0x3F609CU, 0x3F7876U, 0x3F8EF2U, 0x3F9618U, 0x3FA7CCU, 0x3FBF26U, + 0x3FC464U, 0x3FDC8EU, 0x3FED5AU, 0x3FF5B0U, 0x40063AU, 0x401ED0U, 0x402F04U, 0x4037EEU, 0x404CACU, 0x405446U, + 0x406592U, 0x407D78U, 0x408BFCU, 0x409316U, 0x40A2C2U, 0x40BA28U, 0x40C16AU, 0x40D980U, 0x40E854U, 0x40F0BEU, + 0x41055CU, 0x411DB6U, 0x412C62U, 0x413488U, 0x414FCAU, 0x415720U, 0x4166F4U, 0x417E1EU, 0x41889AU, 0x419070U, + 0x41A1A4U, 0x41B94EU, 0x41C20CU, 0x41DAE6U, 0x41EB32U, 0x41F3D8U, 0x4200F6U, 0x42181CU, 0x4229C8U, 0x423122U, + 0x424A60U, 0x42528AU, 0x42635EU, 0x427BB4U, 0x428D30U, 0x4295DAU, 0x42A40EU, 0x42BCE4U, 0x42C7A6U, 0x42DF4CU, + 0x42EE98U, 0x42F672U, 0x430390U, 0x431B7AU, 0x432AAEU, 0x433244U, 0x434906U, 0x4351ECU, 0x436038U, 0x4378D2U, + 0x438E56U, 0x4396BCU, 0x43A768U, 0x43BF82U, 0x43C4C0U, 0x43DC2AU, 0x43EDFEU, 0x43F514U, 0x440BA2U, 0x441348U, + 0x44229CU, 0x443A76U, 0x444134U, 0x4459DEU, 0x44680AU, 0x4470E0U, 0x448664U, 0x449E8EU, 0x44AF5AU, 0x44B7B0U, + 0x44CCF2U, 0x44D418U, 0x44E5CCU, 0x44FD26U, 0x4508C4U, 0x45102EU, 0x4521FAU, 0x453910U, 0x454252U, 0x455AB8U, + 0x456B6CU, 0x457386U, 0x458502U, 0x459DE8U, 0x45AC3CU, 0x45B4D6U, 0x45CF94U, 0x45D77EU, 0x45E6AAU, 0x45FE40U, + 0x460D6EU, 0x461584U, 0x462450U, 0x463CBAU, 0x4647F8U, 0x465F12U, 0x466EC6U, 0x46762CU, 0x4680A8U, 0x469842U, + 0x46A996U, 0x46B17CU, 0x46CA3EU, 0x46D2D4U, 0x46E300U, 0x46FBEAU, 0x470E08U, 0x4716E2U, 0x472736U, 0x473FDCU, + 0x47449EU, 0x475C74U, 0x476DA0U, 0x47754AU, 0x4783CEU, 0x479B24U, 0x47AAF0U, 0x47B21AU, 0x47C958U, 0x47D1B2U, + 0x47E066U, 0x47F88CU, 0x4805E0U, 0x481D0AU, 0x482CDEU, 0x483434U, 0x484F76U, 0x48579CU, 0x486648U, 0x487EA2U, + 0x488826U, 0x4890CCU, 0x48A118U, 0x48B9F2U, 0x48C2B0U, 0x48DA5AU, 0x48EB8EU, 0x48F364U, 0x490686U, 0x491E6CU, + 0x492FB8U, 0x493752U, 0x494C10U, 0x4954FAU, 0x49652EU, 0x497DC4U, 0x498B40U, 0x4993AAU, 0x49A27EU, 0x49BA94U, + 0x49C1D6U, 0x49D93CU, 0x49E8E8U, 0x49F002U, 0x4A032CU, 0x4A1BC6U, 0x4A2A12U, 0x4A32F8U, 0x4A49BAU, 0x4A5150U, + 0x4A6084U, 0x4A786EU, 0x4A8EEAU, 0x4A9600U, 0x4AA7D4U, 0x4ABF3EU, 0x4AC47CU, 0x4ADC96U, 0x4AED42U, 0x4AF5A8U, + 0x4B004AU, 0x4B18A0U, 0x4B2974U, 0x4B319EU, 0x4B4ADCU, 0x4B5236U, 0x4B63E2U, 0x4B7B08U, 0x4B8D8CU, 0x4B9566U, + 0x4BA4B2U, 0x4BBC58U, 0x4BC71AU, 0x4BDFF0U, 0x4BEE24U, 0x4BF6CEU, 0x4C0878U, 0x4C1092U, 0x4C2146U, 0x4C39ACU, + 0x4C42EEU, 0x4C5A04U, 0x4C6BD0U, 0x4C733AU, 0x4C85BEU, 0x4C9D54U, 0x4CAC80U, 0x4CB46AU, 0x4CCF28U, 0x4CD7C2U, + 0x4CE616U, 0x4CFEFCU, 0x4D0B1EU, 0x4D13F4U, 0x4D2220U, 0x4D3ACAU, 0x4D4188U, 0x4D5962U, 0x4D68B6U, 0x4D705CU, + 0x4D86D8U, 0x4D9E32U, 0x4DAFE6U, 0x4DB70CU, 0x4DCC4EU, 0x4DD4A4U, 0x4DE570U, 0x4DFD9AU, 0x4E0EB4U, 0x4E165EU, + 0x4E278AU, 0x4E3F60U, 0x4E4422U, 0x4E5CC8U, 0x4E6D1CU, 0x4E75F6U, 0x4E8372U, 0x4E9B98U, 0x4EAA4CU, 0x4EB2A6U, + 0x4EC9E4U, 0x4ED10EU, 0x4EE0DAU, 0x4EF830U, 0x4F0DD2U, 0x4F1538U, 0x4F24ECU, 0x4F3C06U, 0x4F4744U, 0x4F5FAEU, + 0x4F6E7AU, 0x4F7690U, 0x4F8014U, 0x4F98FEU, 0x4FA92AU, 0x4FB1C0U, 0x4FCA82U, 0x4FD268U, 0x4FE3BCU, 0x4FFB56U, + 0x50018EU, 0x501964U, 0x5028B0U, 0x50305AU, 0x504B18U, 0x5053F2U, 0x506226U, 0x507ACCU, 0x508C48U, 0x5094A2U, + 0x50A576U, 0x50BD9CU, 0x50C6DEU, 0x50DE34U, 0x50EFE0U, 0x50F70AU, 0x5102E8U, 0x511A02U, 0x512BD6U, 0x51333CU, + 0x51487EU, 0x515094U, 0x516140U, 0x5179AAU, 0x518F2EU, 0x5197C4U, 0x51A610U, 0x51BEFAU, 0x51C5B8U, 0x51DD52U, + 0x51EC86U, 0x51F46CU, 0x520742U, 0x521FA8U, 0x522E7CU, 0x523696U, 0x524DD4U, 0x52553EU, 0x5264EAU, 0x527C00U, + 0x528A84U, 0x52926EU, 0x52A3BAU, 0x52BB50U, 0x52C012U, 0x52D8F8U, 0x52E92CU, 0x52F1C6U, 0x530424U, 0x531CCEU, + 0x532D1AU, 0x5335F0U, 0x534EB2U, 0x535658U, 0x53678CU, 0x537F66U, 0x5389E2U, 0x539108U, 0x53A0DCU, 0x53B836U, + 0x53C374U, 0x53DB9EU, 0x53EA4AU, 0x53F2A0U, 0x540C16U, 0x5414FCU, 0x542528U, 0x543DC2U, 0x544680U, 0x545E6AU, + 0x546FBEU, 0x547754U, 0x5481D0U, 0x54993AU, 0x54A8EEU, 0x54B004U, 0x54CB46U, 0x54D3ACU, 0x54E278U, 0x54FA92U, + 0x550F70U, 0x55179AU, 0x55264EU, 0x553EA4U, 0x5545E6U, 0x555D0CU, 0x556CD8U, 0x557432U, 0x5582B6U, 0x559A5CU, + 0x55AB88U, 0x55B362U, 0x55C820U, 0x55D0CAU, 0x55E11EU, 0x55F9F4U, 0x560ADAU, 0x561230U, 0x5623E4U, 0x563B0EU, + 0x56404CU, 0x5658A6U, 0x566972U, 0x567198U, 0x56871CU, 0x569FF6U, 0x56AE22U, 0x56B6C8U, 0x56CD8AU, 0x56D560U, + 0x56E4B4U, 0x56FC5EU, 0x5709BCU, 0x571156U, 0x572082U, 0x573868U, 0x57432AU, 0x575BC0U, 0x576A14U, 0x5772FEU, + 0x57847AU, 0x579C90U, 0x57AD44U, 0x57B5AEU, 0x57CEECU, 0x57D606U, 0x57E7D2U, 0x57FF38U, 0x580254U, 0x581ABEU, + 0x582B6AU, 0x583380U, 0x5848C2U, 0x585028U, 0x5861FCU, 0x587916U, 0x588F92U, 0x589778U, 0x58A6ACU, 0x58BE46U, + 0x58C504U, 0x58DDEEU, 0x58EC3AU, 0x58F4D0U, 0x590132U, 0x5919D8U, 0x59280CU, 0x5930E6U, 0x594BA4U, 0x59534EU, + 0x59629AU, 0x597A70U, 0x598CF4U, 0x59941EU, 0x59A5CAU, 0x59BD20U, 0x59C662U, 0x59DE88U, 0x59EF5CU, 0x59F7B6U, + 0x5A0498U, 0x5A1C72U, 0x5A2DA6U, 0x5A354CU, 0x5A4E0EU, 0x5A56E4U, 0x5A6730U, 0x5A7FDAU, 0x5A895EU, 0x5A91B4U, + 0x5AA060U, 0x5AB88AU, 0x5AC3C8U, 0x5ADB22U, 0x5AEAF6U, 0x5AF21CU, 0x5B07FEU, 0x5B1F14U, 0x5B2EC0U, 0x5B362AU, + 0x5B4D68U, 0x5B5582U, 0x5B6456U, 0x5B7CBCU, 0x5B8A38U, 0x5B92D2U, 0x5BA306U, 0x5BBBECU, 0x5BC0AEU, 0x5BD844U, + 0x5BE990U, 0x5BF17AU, 0x5C0FCCU, 0x5C1726U, 0x5C26F2U, 0x5C3E18U, 0x5C455AU, 0x5C5DB0U, 0x5C6C64U, 0x5C748EU, + 0x5C820AU, 0x5C9AE0U, 0x5CAB34U, 0x5CB3DEU, 0x5CC89CU, 0x5CD076U, 0x5CE1A2U, 0x5CF948U, 0x5D0CAAU, 0x5D1440U, + 0x5D2594U, 0x5D3D7EU, 0x5D463CU, 0x5D5ED6U, 0x5D6F02U, 0x5D77E8U, 0x5D816CU, 0x5D9986U, 0x5DA852U, 0x5DB0B8U, + 0x5DCBFAU, 0x5DD310U, 0x5DE2C4U, 0x5DFA2EU, 0x5E0900U, 0x5E11EAU, 0x5E203EU, 0x5E38D4U, 0x5E4396U, 0x5E5B7CU, + 0x5E6AA8U, 0x5E7242U, 0x5E84C6U, 0x5E9C2CU, 0x5EADF8U, 0x5EB512U, 0x5ECE50U, 0x5ED6BAU, 0x5EE76EU, 0x5EFF84U, + 0x5F0A66U, 0x5F128CU, 0x5F2358U, 0x5F3BB2U, 0x5F40F0U, 0x5F581AU, 0x5F69CEU, 0x5F7124U, 0x5F87A0U, 0x5F9F4AU, + 0x5FAE9EU, 0x5FB674U, 0x5FCD36U, 0x5FD5DCU, 0x5FE408U, 0x5FFCE2U, 0x600952U, 0x6011B8U, 0x60206CU, 0x603886U, + 0x6043C4U, 0x605B2EU, 0x606AFAU, 0x607210U, 0x608494U, 0x609C7EU, 0x60ADAAU, 0x60B540U, 0x60CE02U, 0x60D6E8U, + 0x60E73CU, 0x60FFD6U, 0x610A34U, 0x6112DEU, 0x61230AU, 0x613BE0U, 0x6140A2U, 0x615848U, 0x61699CU, 0x617176U, + 0x6187F2U, 0x619F18U, 0x61AECCU, 0x61B626U, 0x61CD64U, 0x61D58EU, 0x61E45AU, 0x61FCB0U, 0x620F9EU, 0x621774U, + 0x6226A0U, 0x623E4AU, 0x624508U, 0x625DE2U, 0x626C36U, 0x6274DCU, 0x628258U, 0x629AB2U, 0x62AB66U, 0x62B38CU, + 0x62C8CEU, 0x62D024U, 0x62E1F0U, 0x62F91AU, 0x630CF8U, 0x631412U, 0x6325C6U, 0x633D2CU, 0x63466EU, 0x635E84U, + 0x636F50U, 0x6377BAU, 0x63813EU, 0x6399D4U, 0x63A800U, 0x63B0EAU, 0x63CBA8U, 0x63D342U, 0x63E296U, 0x63FA7CU, + 0x6404CAU, 0x641C20U, 0x642DF4U, 0x64351EU, 0x644E5CU, 0x6456B6U, 0x646762U, 0x647F88U, 0x64890CU, 0x6491E6U, + 0x64A032U, 0x64B8D8U, 0x64C39AU, 0x64DB70U, 0x64EAA4U, 0x64F24EU, 0x6507ACU, 0x651F46U, 0x652E92U, 0x653678U, + 0x654D3AU, 0x6555D0U, 0x656404U, 0x657CEEU, 0x658A6AU, 0x659280U, 0x65A354U, 0x65BBBEU, 0x65C0FCU, 0x65D816U, + 0x65E9C2U, 0x65F128U, 0x660206U, 0x661AECU, 0x662B38U, 0x6633D2U, 0x664890U, 0x66507AU, 0x6661AEU, 0x667944U, + 0x668FC0U, 0x66972AU, 0x66A6FEU, 0x66BE14U, 0x66C556U, 0x66DDBCU, 0x66EC68U, 0x66F482U, 0x670160U, 0x67198AU, + 0x67285EU, 0x6730B4U, 0x674BF6U, 0x67531CU, 0x6762C8U, 0x677A22U, 0x678CA6U, 0x67944CU, 0x67A598U, 0x67BD72U, + 0x67C630U, 0x67DEDAU, 0x67EF0EU, 0x67F7E4U, 0x680A88U, 0x681262U, 0x6823B6U, 0x683B5CU, 0x68401EU, 0x6858F4U, + 0x686920U, 0x6871CAU, 0x68874EU, 0x689FA4U, 0x68AE70U, 0x68B69AU, 0x68CDD8U, 0x68D532U, 0x68E4E6U, 0x68FC0CU, + 0x6909EEU, 0x691104U, 0x6920D0U, 0x69383AU, 0x694378U, 0x695B92U, 0x696A46U, 0x6972ACU, 0x698428U, 0x699CC2U, + 0x69AD16U, 0x69B5FCU, 0x69CEBEU, 0x69D654U, 0x69E780U, 0x69FF6AU, 0x6A0C44U, 0x6A14AEU, 0x6A257AU, 0x6A3D90U, + 0x6A46D2U, 0x6A5E38U, 0x6A6FECU, 0x6A7706U, 0x6A8182U, 0x6A9968U, 0x6AA8BCU, 0x6AB056U, 0x6ACB14U, 0x6AD3FEU, + 0x6AE22AU, 0x6AFAC0U, 0x6B0F22U, 0x6B17C8U, 0x6B261CU, 0x6B3EF6U, 0x6B45B4U, 0x6B5D5EU, 0x6B6C8AU, 0x6B7460U, + 0x6B82E4U, 0x6B9A0EU, 0x6BABDAU, 0x6BB330U, 0x6BC872U, 0x6BD098U, 0x6BE14CU, 0x6BF9A6U, 0x6C0710U, 0x6C1FFAU, + 0x6C2E2EU, 0x6C36C4U, 0x6C4D86U, 0x6C556CU, 0x6C64B8U, 0x6C7C52U, 0x6C8AD6U, 0x6C923CU, 0x6CA3E8U, 0x6CBB02U, + 0x6CC040U, 0x6CD8AAU, 0x6CE97EU, 0x6CF194U, 0x6D0476U, 0x6D1C9CU, 0x6D2D48U, 0x6D35A2U, 0x6D4EE0U, 0x6D560AU, + 0x6D67DEU, 0x6D7F34U, 0x6D89B0U, 0x6D915AU, 0x6DA08EU, 0x6DB864U, 0x6DC326U, 0x6DDBCCU, 0x6DEA18U, 0x6DF2F2U, + 0x6E01DCU, 0x6E1936U, 0x6E28E2U, 0x6E3008U, 0x6E4B4AU, 0x6E53A0U, 0x6E6274U, 0x6E7A9EU, 0x6E8C1AU, 0x6E94F0U, + 0x6EA524U, 0x6EBDCEU, 0x6EC68CU, 0x6EDE66U, 0x6EEFB2U, 0x6EF758U, 0x6F02BAU, 0x6F1A50U, 0x6F2B84U, 0x6F336EU, + 0x6F482CU, 0x6F50C6U, 0x6F6112U, 0x6F79F8U, 0x6F8F7CU, 0x6F9796U, 0x6FA642U, 0x6FBEA8U, 0x6FC5EAU, 0x6FDD00U, + 0x6FECD4U, 0x6FF43EU, 0x700EE6U, 0x70160CU, 0x7027D8U, 0x703F32U, 0x704470U, 0x705C9AU, 0x706D4EU, 0x7075A4U, + 0x708320U, 0x709BCAU, 0x70AA1EU, 0x70B2F4U, 0x70C9B6U, 0x70D15CU, 0x70E088U, 0x70F862U, 0x710D80U, 0x71156AU, + 0x7124BEU, 0x713C54U, 0x714716U, 0x715FFCU, 0x716E28U, 0x7176C2U, 0x718046U, 0x7198ACU, 0x71A978U, 0x71B192U, + 0x71CAD0U, 0x71D23AU, 0x71E3EEU, 0x71FB04U, 0x72082AU, 0x7210C0U, 0x722114U, 0x7239FEU, 0x7242BCU, 0x725A56U, + 0x726B82U, 0x727368U, 0x7285ECU, 0x729D06U, 0x72ACD2U, 0x72B438U, 0x72CF7AU, 0x72D790U, 0x72E644U, 0x72FEAEU, + 0x730B4CU, 0x7313A6U, 0x732272U, 0x733A98U, 0x7341DAU, 0x735930U, 0x7368E4U, 0x73700EU, 0x73868AU, 0x739E60U, + 0x73AFB4U, 0x73B75EU, 0x73CC1CU, 0x73D4F6U, 0x73E522U, 0x73FDC8U, 0x74037EU, 0x741B94U, 0x742A40U, 0x7432AAU, + 0x7449E8U, 0x745102U, 0x7460D6U, 0x74783CU, 0x748EB8U, 0x749652U, 0x74A786U, 0x74BF6CU, 0x74C42EU, 0x74DCC4U, + 0x74ED10U, 0x74F5FAU, 0x750018U, 0x7518F2U, 0x752926U, 0x7531CCU, 0x754A8EU, 0x755264U, 0x7563B0U, 0x757B5AU, + 0x758DDEU, 0x759534U, 0x75A4E0U, 0x75BC0AU, 0x75C748U, 0x75DFA2U, 0x75EE76U, 0x75F69CU, 0x7605B2U, 0x761D58U, + 0x762C8CU, 0x763466U, 0x764F24U, 0x7657CEU, 0x76661AU, 0x767EF0U, 0x768874U, 0x76909EU, 0x76A14AU, 0x76B9A0U, + 0x76C2E2U, 0x76DA08U, 0x76EBDCU, 0x76F336U, 0x7706D4U, 0x771E3EU, 0x772FEAU, 0x773700U, 0x774C42U, 0x7754A8U, + 0x77657CU, 0x777D96U, 0x778B12U, 0x7793F8U, 0x77A22CU, 0x77BAC6U, 0x77C184U, 0x77D96EU, 0x77E8BAU, 0x77F050U, + 0x780D3CU, 0x7815D6U, 0x782402U, 0x783CE8U, 0x7847AAU, 0x785F40U, 0x786E94U, 0x78767EU, 0x7880FAU, 0x789810U, + 0x78A9C4U, 0x78B12EU, 0x78CA6CU, 0x78D286U, 0x78E352U, 0x78FBB8U, 0x790E5AU, 0x7916B0U, 0x792764U, 0x793F8EU, + 0x7944CCU, 0x795C26U, 0x796DF2U, 0x797518U, 0x79839CU, 0x799B76U, 0x79AAA2U, 0x79B248U, 0x79C90AU, 0x79D1E0U, + 0x79E034U, 0x79F8DEU, 0x7A0BF0U, 0x7A131AU, 0x7A22CEU, 0x7A3A24U, 0x7A4166U, 0x7A598CU, 0x7A6858U, 0x7A70B2U, + 0x7A8636U, 0x7A9EDCU, 0x7AAF08U, 0x7AB7E2U, 0x7ACCA0U, 0x7AD44AU, 0x7AE59EU, 0x7AFD74U, 0x7B0896U, 0x7B107CU, + 0x7B21A8U, 0x7B3942U, 0x7B4200U, 0x7B5AEAU, 0x7B6B3EU, 0x7B73D4U, 0x7B8550U, 0x7B9DBAU, 0x7BAC6EU, 0x7BB484U, + 0x7BCFC6U, 0x7BD72CU, 0x7BE6F8U, 0x7BFE12U, 0x7C00A4U, 0x7C184EU, 0x7C299AU, 0x7C3170U, 0x7C4A32U, 0x7C52D8U, + 0x7C630CU, 0x7C7BE6U, 0x7C8D62U, 0x7C9588U, 0x7CA45CU, 0x7CBCB6U, 0x7CC7F4U, 0x7CDF1EU, 0x7CEECAU, 0x7CF620U, + 0x7D03C2U, 0x7D1B28U, 0x7D2AFCU, 0x7D3216U, 0x7D4954U, 0x7D51BEU, 0x7D606AU, 0x7D7880U, 0x7D8E04U, 0x7D96EEU, + 0x7DA73AU, 0x7DBFD0U, 0x7DC492U, 0x7DDC78U, 0x7DEDACU, 0x7DF546U, 0x7E0668U, 0x7E1E82U, 0x7E2F56U, 0x7E37BCU, + 0x7E4CFEU, 0x7E5414U, 0x7E65C0U, 0x7E7D2AU, 0x7E8BAEU, 0x7E9344U, 0x7EA290U, 0x7EBA7AU, 0x7EC138U, 0x7ED9D2U, + 0x7EE806U, 0x7EF0ECU, 0x7F050EU, 0x7F1DE4U, 0x7F2C30U, 0x7F34DAU, 0x7F4F98U, 0x7F5772U, 0x7F66A6U, 0x7F7E4CU, + 0x7F88C8U, 0x7F9022U, 0x7FA1F6U, 0x7FB91CU, 0x7FC25EU, 0x7FDAB4U, 0x7FEB60U, 0x7FF38AU, 0x800C74U, 0x80149EU, + 0x80254AU, 0x803DA0U, 0x8046E2U, 0x805E08U, 0x806FDCU, 0x807736U, 0x8081B2U, 0x809958U, 0x80A88CU, 0x80B066U, + 0x80CB24U, 0x80D3CEU, 0x80E21AU, 0x80FAF0U, 0x810F12U, 0x8117F8U, 0x81262CU, 0x813EC6U, 0x814584U, 0x815D6EU, + 0x816CBAU, 0x817450U, 0x8182D4U, 0x819A3EU, 0x81ABEAU, 0x81B300U, 0x81C842U, 0x81D0A8U, 0x81E17CU, 0x81F996U, + 0x820AB8U, 0x821252U, 0x822386U, 0x823B6CU, 0x82402EU, 0x8258C4U, 0x826910U, 0x8271FAU, 0x82877EU, 0x829F94U, + 0x82AE40U, 0x82B6AAU, 0x82CDE8U, 0x82D502U, 0x82E4D6U, 0x82FC3CU, 0x8309DEU, 0x831134U, 0x8320E0U, 0x83380AU, + 0x834348U, 0x835BA2U, 0x836A76U, 0x83729CU, 0x838418U, 0x839CF2U, 0x83AD26U, 0x83B5CCU, 0x83CE8EU, 0x83D664U, + 0x83E7B0U, 0x83FF5AU, 0x8401ECU, 0x841906U, 0x8428D2U, 0x843038U, 0x844B7AU, 0x845390U, 0x846244U, 0x847AAEU, + 0x848C2AU, 0x8494C0U, 0x84A514U, 0x84BDFEU, 0x84C6BCU, 0x84DE56U, 0x84EF82U, 0x84F768U, 0x85028AU, 0x851A60U, + 0x852BB4U, 0x85335EU, 0x85481CU, 0x8550F6U, 0x856122U, 0x8579C8U, 0x858F4CU, 0x8597A6U, 0x85A672U, 0x85BE98U, + 0x85C5DAU, 0x85DD30U, 0x85ECE4U, 0x85F40EU, 0x860720U, 0x861FCAU, 0x862E1EU, 0x8636F4U, 0x864DB6U, 0x86555CU, + 0x866488U, 0x867C62U, 0x868AE6U, 0x86920CU, 0x86A3D8U, 0x86BB32U, 0x86C070U, 0x86D89AU, 0x86E94EU, 0x86F1A4U, + 0x870446U, 0x871CACU, 0x872D78U, 0x873592U, 0x874ED0U, 0x87563AU, 0x8767EEU, 0x877F04U, 0x878980U, 0x87916AU, + 0x87A0BEU, 0x87B854U, 0x87C316U, 0x87DBFCU, 0x87EA28U, 0x87F2C2U, 0x880FAEU, 0x881744U, 0x882690U, 0x883E7AU, + 0x884538U, 0x885DD2U, 0x886C06U, 0x8874ECU, 0x888268U, 0x889A82U, 0x88AB56U, 0x88B3BCU, 0x88C8FEU, 0x88D014U, + 0x88E1C0U, 0x88F92AU, 0x890CC8U, 0x891422U, 0x8925F6U, 0x893D1CU, 0x89465EU, 0x895EB4U, 0x896F60U, 0x89778AU, + 0x89810EU, 0x8999E4U, 0x89A830U, 0x89B0DAU, 0x89CB98U, 0x89D372U, 0x89E2A6U, 0x89FA4CU, 0x8A0962U, 0x8A1188U, + 0x8A205CU, 0x8A38B6U, 0x8A43F4U, 0x8A5B1EU, 0x8A6ACAU, 0x8A7220U, 0x8A84A4U, 0x8A9C4EU, 0x8AAD9AU, 0x8AB570U, + 0x8ACE32U, 0x8AD6D8U, 0x8AE70CU, 0x8AFFE6U, 0x8B0A04U, 0x8B12EEU, 0x8B233AU, 0x8B3BD0U, 0x8B4092U, 0x8B5878U, + 0x8B69ACU, 0x8B7146U, 0x8B87C2U, 0x8B9F28U, 0x8BAEFCU, 0x8BB616U, 0x8BCD54U, 0x8BD5BEU, 0x8BE46AU, 0x8BFC80U, + 0x8C0236U, 0x8C1ADCU, 0x8C2B08U, 0x8C33E2U, 0x8C48A0U, 0x8C504AU, 0x8C619EU, 0x8C7974U, 0x8C8FF0U, 0x8C971AU, + 0x8CA6CEU, 0x8CBE24U, 0x8CC566U, 0x8CDD8CU, 0x8CEC58U, 0x8CF4B2U, 0x8D0150U, 0x8D19BAU, 0x8D286EU, 0x8D3084U, + 0x8D4BC6U, 0x8D532CU, 0x8D62F8U, 0x8D7A12U, 0x8D8C96U, 0x8D947CU, 0x8DA5A8U, 0x8DBD42U, 0x8DC600U, 0x8DDEEAU, + 0x8DEF3EU, 0x8DF7D4U, 0x8E04FAU, 0x8E1C10U, 0x8E2DC4U, 0x8E352EU, 0x8E4E6CU, 0x8E5686U, 0x8E6752U, 0x8E7FB8U, + 0x8E893CU, 0x8E91D6U, 0x8EA002U, 0x8EB8E8U, 0x8EC3AAU, 0x8EDB40U, 0x8EEA94U, 0x8EF27EU, 0x8F079CU, 0x8F1F76U, + 0x8F2EA2U, 0x8F3648U, 0x8F4D0AU, 0x8F55E0U, 0x8F6434U, 0x8F7CDEU, 0x8F8A5AU, 0x8F92B0U, 0x8FA364U, 0x8FBB8EU, + 0x8FC0CCU, 0x8FD826U, 0x8FE9F2U, 0x8FF118U, 0x900BC0U, 0x90132AU, 0x9022FEU, 0x903A14U, 0x904156U, 0x9059BCU, + 0x906868U, 0x907082U, 0x908606U, 0x909EECU, 0x90AF38U, 0x90B7D2U, 0x90CC90U, 0x90D47AU, 0x90E5AEU, 0x90FD44U, + 0x9108A6U, 0x91104CU, 0x912198U, 0x913972U, 0x914230U, 0x915ADAU, 0x916B0EU, 0x9173E4U, 0x918560U, 0x919D8AU, + 0x91AC5EU, 0x91B4B4U, 0x91CFF6U, 0x91D71CU, 0x91E6C8U, 0x91FE22U, 0x920D0CU, 0x9215E6U, 0x922432U, 0x923CD8U, + 0x92479AU, 0x925F70U, 0x926EA4U, 0x92764EU, 0x9280CAU, 0x929820U, 0x92A9F4U, 0x92B11EU, 0x92CA5CU, 0x92D2B6U, + 0x92E362U, 0x92FB88U, 0x930E6AU, 0x931680U, 0x932754U, 0x933FBEU, 0x9344FCU, 0x935C16U, 0x936DC2U, 0x937528U, + 0x9383ACU, 0x939B46U, 0x93AA92U, 0x93B278U, 0x93C93AU, 0x93D1D0U, 0x93E004U, 0x93F8EEU, 0x940658U, 0x941EB2U, + 0x942F66U, 0x94378CU, 0x944CCEU, 0x945424U, 0x9465F0U, 0x947D1AU, 0x948B9EU, 0x949374U, 0x94A2A0U, 0x94BA4AU, + 0x94C108U, 0x94D9E2U, 0x94E836U, 0x94F0DCU, 0x95053EU, 0x951DD4U, 0x952C00U, 0x9534EAU, 0x954FA8U, 0x955742U, + 0x956696U, 0x957E7CU, 0x9588F8U, 0x959012U, 0x95A1C6U, 0x95B92CU, 0x95C26EU, 0x95DA84U, 0x95EB50U, 0x95F3BAU, + 0x960094U, 0x96187EU, 0x9629AAU, 0x963140U, 0x964A02U, 0x9652E8U, 0x96633CU, 0x967BD6U, 0x968D52U, 0x9695B8U, + 0x96A46CU, 0x96BC86U, 0x96C7C4U, 0x96DF2EU, 0x96EEFAU, 0x96F610U, 0x9703F2U, 0x971B18U, 0x972ACCU, 0x973226U, + 0x974964U, 0x97518EU, 0x97605AU, 0x9778B0U, 0x978E34U, 0x9796DEU, 0x97A70AU, 0x97BFE0U, 0x97C4A2U, 0x97DC48U, + 0x97ED9CU, 0x97F576U, 0x98081AU, 0x9810F0U, 0x982124U, 0x9839CEU, 0x98428CU, 0x985A66U, 0x986BB2U, 0x987358U, + 0x9885DCU, 0x989D36U, 0x98ACE2U, 0x98B408U, 0x98CF4AU, 0x98D7A0U, 0x98E674U, 0x98FE9EU, 0x990B7CU, 0x991396U, + 0x992242U, 0x993AA8U, 0x9941EAU, 0x995900U, 0x9968D4U, 0x99703EU, 0x9986BAU, 0x999E50U, 0x99AF84U, 0x99B76EU, + 0x99CC2CU, 0x99D4C6U, 0x99E512U, 0x99FDF8U, 0x9A0ED6U, 0x9A163CU, 0x9A27E8U, 0x9A3F02U, 0x9A4440U, 0x9A5CAAU, + 0x9A6D7EU, 0x9A7594U, 0x9A8310U, 0x9A9BFAU, 0x9AAA2EU, 0x9AB2C4U, 0x9AC986U, 0x9AD16CU, 0x9AE0B8U, 0x9AF852U, + 0x9B0DB0U, 0x9B155AU, 0x9B248EU, 0x9B3C64U, 0x9B4726U, 0x9B5FCCU, 0x9B6E18U, 0x9B76F2U, 0x9B8076U, 0x9B989CU, + 0x9BA948U, 0x9BB1A2U, 0x9BCAE0U, 0x9BD20AU, 0x9BE3DEU, 0x9BFB34U, 0x9C0582U, 0x9C1D68U, 0x9C2CBCU, 0x9C3456U, + 0x9C4F14U, 0x9C57FEU, 0x9C662AU, 0x9C7EC0U, 0x9C8844U, 0x9C90AEU, 0x9CA17AU, 0x9CB990U, 0x9CC2D2U, 0x9CDA38U, + 0x9CEBECU, 0x9CF306U, 0x9D06E4U, 0x9D1E0EU, 0x9D2FDAU, 0x9D3730U, 0x9D4C72U, 0x9D5498U, 0x9D654CU, 0x9D7DA6U, + 0x9D8B22U, 0x9D93C8U, 0x9DA21CU, 0x9DBAF6U, 0x9DC1B4U, 0x9DD95EU, 0x9DE88AU, 0x9DF060U, 0x9E034EU, 0x9E1BA4U, + 0x9E2A70U, 0x9E329AU, 0x9E49D8U, 0x9E5132U, 0x9E60E6U, 0x9E780CU, 0x9E8E88U, 0x9E9662U, 0x9EA7B6U, 0x9EBF5CU, + 0x9EC41EU, 0x9EDCF4U, 0x9EED20U, 0x9EF5CAU, 0x9F0028U, 0x9F18C2U, 0x9F2916U, 0x9F31FCU, 0x9F4ABEU, 0x9F5254U, + 0x9F6380U, 0x9F7B6AU, 0x9F8DEEU, 0x9F9504U, 0x9FA4D0U, 0x9FBC3AU, 0x9FC778U, 0x9FDF92U, 0x9FEE46U, 0x9FF6ACU, + 0xA0031CU, 0xA01BF6U, 0xA02A22U, 0xA032C8U, 0xA0498AU, 0xA05160U, 0xA060B4U, 0xA0785EU, 0xA08EDAU, 0xA09630U, + 0xA0A7E4U, 0xA0BF0EU, 0xA0C44CU, 0xA0DCA6U, 0xA0ED72U, 0xA0F598U, 0xA1007AU, 0xA11890U, 0xA12944U, 0xA131AEU, + 0xA14AECU, 0xA15206U, 0xA163D2U, 0xA17B38U, 0xA18DBCU, 0xA19556U, 0xA1A482U, 0xA1BC68U, 0xA1C72AU, 0xA1DFC0U, + 0xA1EE14U, 0xA1F6FEU, 0xA205D0U, 0xA21D3AU, 0xA22CEEU, 0xA23404U, 0xA24F46U, 0xA257ACU, 0xA26678U, 0xA27E92U, + 0xA28816U, 0xA290FCU, 0xA2A128U, 0xA2B9C2U, 0xA2C280U, 0xA2DA6AU, 0xA2EBBEU, 0xA2F354U, 0xA306B6U, 0xA31E5CU, + 0xA32F88U, 0xA33762U, 0xA34C20U, 0xA354CAU, 0xA3651EU, 0xA37DF4U, 0xA38B70U, 0xA3939AU, 0xA3A24EU, 0xA3BAA4U, + 0xA3C1E6U, 0xA3D90CU, 0xA3E8D8U, 0xA3F032U, 0xA40E84U, 0xA4166EU, 0xA427BAU, 0xA43F50U, 0xA44412U, 0xA45CF8U, + 0xA46D2CU, 0xA475C6U, 0xA48342U, 0xA49BA8U, 0xA4AA7CU, 0xA4B296U, 0xA4C9D4U, 0xA4D13EU, 0xA4E0EAU, 0xA4F800U, + 0xA50DE2U, 0xA51508U, 0xA524DCU, 0xA53C36U, 0xA54774U, 0xA55F9EU, 0xA56E4AU, 0xA576A0U, 0xA58024U, 0xA598CEU, + 0xA5A91AU, 0xA5B1F0U, 0xA5CAB2U, 0xA5D258U, 0xA5E38CU, 0xA5FB66U, 0xA60848U, 0xA610A2U, 0xA62176U, 0xA6399CU, + 0xA642DEU, 0xA65A34U, 0xA66BE0U, 0xA6730AU, 0xA6858EU, 0xA69D64U, 0xA6ACB0U, 0xA6B45AU, 0xA6CF18U, 0xA6D7F2U, + 0xA6E626U, 0xA6FECCU, 0xA70B2EU, 0xA713C4U, 0xA72210U, 0xA73AFAU, 0xA741B8U, 0xA75952U, 0xA76886U, 0xA7706CU, + 0xA786E8U, 0xA79E02U, 0xA7AFD6U, 0xA7B73CU, 0xA7CC7EU, 0xA7D494U, 0xA7E540U, 0xA7FDAAU, 0xA800C6U, 0xA8182CU, + 0xA829F8U, 0xA83112U, 0xA84A50U, 0xA852BAU, 0xA8636EU, 0xA87B84U, 0xA88D00U, 0xA895EAU, 0xA8A43EU, 0xA8BCD4U, + 0xA8C796U, 0xA8DF7CU, 0xA8EEA8U, 0xA8F642U, 0xA903A0U, 0xA91B4AU, 0xA92A9EU, 0xA93274U, 0xA94936U, 0xA951DCU, + 0xA96008U, 0xA978E2U, 0xA98E66U, 0xA9968CU, 0xA9A758U, 0xA9BFB2U, 0xA9C4F0U, 0xA9DC1AU, 0xA9EDCEU, 0xA9F524U, + 0xAA060AU, 0xAA1EE0U, 0xAA2F34U, 0xAA37DEU, 0xAA4C9CU, 0xAA5476U, 0xAA65A2U, 0xAA7D48U, 0xAA8BCCU, 0xAA9326U, + 0xAAA2F2U, 0xAABA18U, 0xAAC15AU, 0xAAD9B0U, 0xAAE864U, 0xAAF08EU, 0xAB056CU, 0xAB1D86U, 0xAB2C52U, 0xAB34B8U, + 0xAB4FFAU, 0xAB5710U, 0xAB66C4U, 0xAB7E2EU, 0xAB88AAU, 0xAB9040U, 0xABA194U, 0xABB97EU, 0xABC23CU, 0xABDAD6U, + 0xABEB02U, 0xABF3E8U, 0xAC0D5EU, 0xAC15B4U, 0xAC2460U, 0xAC3C8AU, 0xAC47C8U, 0xAC5F22U, 0xAC6EF6U, 0xAC761CU, + 0xAC8098U, 0xAC9872U, 0xACA9A6U, 0xACB14CU, 0xACCA0EU, 0xACD2E4U, 0xACE330U, 0xACFBDAU, 0xAD0E38U, 0xAD16D2U, + 0xAD2706U, 0xAD3FECU, 0xAD44AEU, 0xAD5C44U, 0xAD6D90U, 0xAD757AU, 0xAD83FEU, 0xAD9B14U, 0xADAAC0U, 0xADB22AU, + 0xADC968U, 0xADD182U, 0xADE056U, 0xADF8BCU, 0xAE0B92U, 0xAE1378U, 0xAE22ACU, 0xAE3A46U, 0xAE4104U, 0xAE59EEU, + 0xAE683AU, 0xAE70D0U, 0xAE8654U, 0xAE9EBEU, 0xAEAF6AU, 0xAEB780U, 0xAECCC2U, 0xAED428U, 0xAEE5FCU, 0xAEFD16U, + 0xAF08F4U, 0xAF101EU, 0xAF21CAU, 0xAF3920U, 0xAF4262U, 0xAF5A88U, 0xAF6B5CU, 0xAF73B6U, 0xAF8532U, 0xAF9DD8U, + 0xAFAC0CU, 0xAFB4E6U, 0xAFCFA4U, 0xAFD74EU, 0xAFE69AU, 0xAFFE70U, 0xB004A8U, 0xB01C42U, 0xB02D96U, 0xB0357CU, + 0xB04E3EU, 0xB056D4U, 0xB06700U, 0xB07FEAU, 0xB0896EU, 0xB09184U, 0xB0A050U, 0xB0B8BAU, 0xB0C3F8U, 0xB0DB12U, + 0xB0EAC6U, 0xB0F22CU, 0xB107CEU, 0xB11F24U, 0xB12EF0U, 0xB1361AU, 0xB14D58U, 0xB155B2U, 0xB16466U, 0xB17C8CU, + 0xB18A08U, 0xB192E2U, 0xB1A336U, 0xB1BBDCU, 0xB1C09EU, 0xB1D874U, 0xB1E9A0U, 0xB1F14AU, 0xB20264U, 0xB21A8EU, + 0xB22B5AU, 0xB233B0U, 0xB248F2U, 0xB25018U, 0xB261CCU, 0xB27926U, 0xB28FA2U, 0xB29748U, 0xB2A69CU, 0xB2BE76U, + 0xB2C534U, 0xB2DDDEU, 0xB2EC0AU, 0xB2F4E0U, 0xB30102U, 0xB319E8U, 0xB3283CU, 0xB330D6U, 0xB34B94U, 0xB3537EU, + 0xB362AAU, 0xB37A40U, 0xB38CC4U, 0xB3942EU, 0xB3A5FAU, 0xB3BD10U, 0xB3C652U, 0xB3DEB8U, 0xB3EF6CU, 0xB3F786U, + 0xB40930U, 0xB411DAU, 0xB4200EU, 0xB438E4U, 0xB443A6U, 0xB45B4CU, 0xB46A98U, 0xB47272U, 0xB484F6U, 0xB49C1CU, + 0xB4ADC8U, 0xB4B522U, 0xB4CE60U, 0xB4D68AU, 0xB4E75EU, 0xB4FFB4U, 0xB50A56U, 0xB512BCU, 0xB52368U, 0xB53B82U, + 0xB540C0U, 0xB5582AU, 0xB569FEU, 0xB57114U, 0xB58790U, 0xB59F7AU, 0xB5AEAEU, 0xB5B644U, 0xB5CD06U, 0xB5D5ECU, + 0xB5E438U, 0xB5FCD2U, 0xB60FFCU, 0xB61716U, 0xB626C2U, 0xB63E28U, 0xB6456AU, 0xB65D80U, 0xB66C54U, 0xB674BEU, + 0xB6823AU, 0xB69AD0U, 0xB6AB04U, 0xB6B3EEU, 0xB6C8ACU, 0xB6D046U, 0xB6E192U, 0xB6F978U, 0xB70C9AU, 0xB71470U, + 0xB725A4U, 0xB73D4EU, 0xB7460CU, 0xB75EE6U, 0xB76F32U, 0xB777D8U, 0xB7815CU, 0xB799B6U, 0xB7A862U, 0xB7B088U, + 0xB7CBCAU, 0xB7D320U, 0xB7E2F4U, 0xB7FA1EU, 0xB80772U, 0xB81F98U, 0xB82E4CU, 0xB836A6U, 0xB84DE4U, 0xB8550EU, + 0xB864DAU, 0xB87C30U, 0xB88AB4U, 0xB8925EU, 0xB8A38AU, 0xB8BB60U, 0xB8C022U, 0xB8D8C8U, 0xB8E91CU, 0xB8F1F6U, + 0xB90414U, 0xB91CFEU, 0xB92D2AU, 0xB935C0U, 0xB94E82U, 0xB95668U, 0xB967BCU, 0xB97F56U, 0xB989D2U, 0xB99138U, + 0xB9A0ECU, 0xB9B806U, 0xB9C344U, 0xB9DBAEU, 0xB9EA7AU, 0xB9F290U, 0xBA01BEU, 0xBA1954U, 0xBA2880U, 0xBA306AU, + 0xBA4B28U, 0xBA53C2U, 0xBA6216U, 0xBA7AFCU, 0xBA8C78U, 0xBA9492U, 0xBAA546U, 0xBABDACU, 0xBAC6EEU, 0xBADE04U, + 0xBAEFD0U, 0xBAF73AU, 0xBB02D8U, 0xBB1A32U, 0xBB2BE6U, 0xBB330CU, 0xBB484EU, 0xBB50A4U, 0xBB6170U, 0xBB799AU, + 0xBB8F1EU, 0xBB97F4U, 0xBBA620U, 0xBBBECAU, 0xBBC588U, 0xBBDD62U, 0xBBECB6U, 0xBBF45CU, 0xBC0AEAU, 0xBC1200U, + 0xBC23D4U, 0xBC3B3EU, 0xBC407CU, 0xBC5896U, 0xBC6942U, 0xBC71A8U, 0xBC872CU, 0xBC9FC6U, 0xBCAE12U, 0xBCB6F8U, + 0xBCCDBAU, 0xBCD550U, 0xBCE484U, 0xBCFC6EU, 0xBD098CU, 0xBD1166U, 0xBD20B2U, 0xBD3858U, 0xBD431AU, 0xBD5BF0U, + 0xBD6A24U, 0xBD72CEU, 0xBD844AU, 0xBD9CA0U, 0xBDAD74U, 0xBDB59EU, 0xBDCEDCU, 0xBDD636U, 0xBDE7E2U, 0xBDFF08U, + 0xBE0C26U, 0xBE14CCU, 0xBE2518U, 0xBE3DF2U, 0xBE46B0U, 0xBE5E5AU, 0xBE6F8EU, 0xBE7764U, 0xBE81E0U, 0xBE990AU, + 0xBEA8DEU, 0xBEB034U, 0xBECB76U, 0xBED39CU, 0xBEE248U, 0xBEFAA2U, 0xBF0F40U, 0xBF17AAU, 0xBF267EU, 0xBF3E94U, + 0xBF45D6U, 0xBF5D3CU, 0xBF6CE8U, 0xBF7402U, 0xBF8286U, 0xBF9A6CU, 0xBFABB8U, 0xBFB352U, 0xBFC810U, 0xBFD0FAU, + 0xBFE12EU, 0xBFF9C4U, 0xC00A4EU, 0xC012A4U, 0xC02370U, 0xC03B9AU, 0xC040D8U, 0xC05832U, 0xC069E6U, 0xC0710CU, + 0xC08788U, 0xC09F62U, 0xC0AEB6U, 0xC0B65CU, 0xC0CD1EU, 0xC0D5F4U, 0xC0E420U, 0xC0FCCAU, 0xC10928U, 0xC111C2U, + 0xC12016U, 0xC138FCU, 0xC143BEU, 0xC15B54U, 0xC16A80U, 0xC1726AU, 0xC184EEU, 0xC19C04U, 0xC1ADD0U, 0xC1B53AU, + 0xC1CE78U, 0xC1D692U, 0xC1E746U, 0xC1FFACU, 0xC20C82U, 0xC21468U, 0xC225BCU, 0xC23D56U, 0xC24614U, 0xC25EFEU, + 0xC26F2AU, 0xC277C0U, 0xC28144U, 0xC299AEU, 0xC2A87AU, 0xC2B090U, 0xC2CBD2U, 0xC2D338U, 0xC2E2ECU, 0xC2FA06U, + 0xC30FE4U, 0xC3170EU, 0xC326DAU, 0xC33E30U, 0xC34572U, 0xC35D98U, 0xC36C4CU, 0xC374A6U, 0xC38222U, 0xC39AC8U, + 0xC3AB1CU, 0xC3B3F6U, 0xC3C8B4U, 0xC3D05EU, 0xC3E18AU, 0xC3F960U, 0xC407D6U, 0xC41F3CU, 0xC42EE8U, 0xC43602U, + 0xC44D40U, 0xC455AAU, 0xC4647EU, 0xC47C94U, 0xC48A10U, 0xC492FAU, 0xC4A32EU, 0xC4BBC4U, 0xC4C086U, 0xC4D86CU, + 0xC4E9B8U, 0xC4F152U, 0xC504B0U, 0xC51C5AU, 0xC52D8EU, 0xC53564U, 0xC54E26U, 0xC556CCU, 0xC56718U, 0xC57FF2U, + 0xC58976U, 0xC5919CU, 0xC5A048U, 0xC5B8A2U, 0xC5C3E0U, 0xC5DB0AU, 0xC5EADEU, 0xC5F234U, 0xC6011AU, 0xC619F0U, + 0xC62824U, 0xC630CEU, 0xC64B8CU, 0xC65366U, 0xC662B2U, 0xC67A58U, 0xC68CDCU, 0xC69436U, 0xC6A5E2U, 0xC6BD08U, + 0xC6C64AU, 0xC6DEA0U, 0xC6EF74U, 0xC6F79EU, 0xC7027CU, 0xC71A96U, 0xC72B42U, 0xC733A8U, 0xC748EAU, 0xC75000U, + 0xC761D4U, 0xC7793EU, 0xC78FBAU, 0xC79750U, 0xC7A684U, 0xC7BE6EU, 0xC7C52CU, 0xC7DDC6U, 0xC7EC12U, 0xC7F4F8U, + 0xC80994U, 0xC8117EU, 0xC820AAU, 0xC83840U, 0xC84302U, 0xC85BE8U, 0xC86A3CU, 0xC872D6U, 0xC88452U, 0xC89CB8U, + 0xC8AD6CU, 0xC8B586U, 0xC8CEC4U, 0xC8D62EU, 0xC8E7FAU, 0xC8FF10U, 0xC90AF2U, 0xC91218U, 0xC923CCU, 0xC93B26U, + 0xC94064U, 0xC9588EU, 0xC9695AU, 0xC971B0U, 0xC98734U, 0xC99FDEU, 0xC9AE0AU, 0xC9B6E0U, 0xC9CDA2U, 0xC9D548U, + 0xC9E49CU, 0xC9FC76U, 0xCA0F58U, 0xCA17B2U, 0xCA2666U, 0xCA3E8CU, 0xCA45CEU, 0xCA5D24U, 0xCA6CF0U, 0xCA741AU, + 0xCA829EU, 0xCA9A74U, 0xCAABA0U, 0xCAB34AU, 0xCAC808U, 0xCAD0E2U, 0xCAE136U, 0xCAF9DCU, 0xCB0C3EU, 0xCB14D4U, + 0xCB2500U, 0xCB3DEAU, 0xCB46A8U, 0xCB5E42U, 0xCB6F96U, 0xCB777CU, 0xCB81F8U, 0xCB9912U, 0xCBA8C6U, 0xCBB02CU, + 0xCBCB6EU, 0xCBD384U, 0xCBE250U, 0xCBFABAU, 0xCC040CU, 0xCC1CE6U, 0xCC2D32U, 0xCC35D8U, 0xCC4E9AU, 0xCC5670U, + 0xCC67A4U, 0xCC7F4EU, 0xCC89CAU, 0xCC9120U, 0xCCA0F4U, 0xCCB81EU, 0xCCC35CU, 0xCCDBB6U, 0xCCEA62U, 0xCCF288U, + 0xCD076AU, 0xCD1F80U, 0xCD2E54U, 0xCD36BEU, 0xCD4DFCU, 0xCD5516U, 0xCD64C2U, 0xCD7C28U, 0xCD8AACU, 0xCD9246U, + 0xCDA392U, 0xCDBB78U, 0xCDC03AU, 0xCDD8D0U, 0xCDE904U, 0xCDF1EEU, 0xCE02C0U, 0xCE1A2AU, 0xCE2BFEU, 0xCE3314U, + 0xCE4856U, 0xCE50BCU, 0xCE6168U, 0xCE7982U, 0xCE8F06U, 0xCE97ECU, 0xCEA638U, 0xCEBED2U, 0xCEC590U, 0xCEDD7AU, + 0xCEECAEU, 0xCEF444U, 0xCF01A6U, 0xCF194CU, 0xCF2898U, 0xCF3072U, 0xCF4B30U, 0xCF53DAU, 0xCF620EU, 0xCF7AE4U, + 0xCF8C60U, 0xCF948AU, 0xCFA55EU, 0xCFBDB4U, 0xCFC6F6U, 0xCFDE1CU, 0xCFEFC8U, 0xCFF722U, 0xD00DFAU, 0xD01510U, + 0xD024C4U, 0xD03C2EU, 0xD0476CU, 0xD05F86U, 0xD06E52U, 0xD076B8U, 0xD0803CU, 0xD098D6U, 0xD0A902U, 0xD0B1E8U, + 0xD0CAAAU, 0xD0D240U, 0xD0E394U, 0xD0FB7EU, 0xD10E9CU, 0xD11676U, 0xD127A2U, 0xD13F48U, 0xD1440AU, 0xD15CE0U, + 0xD16D34U, 0xD175DEU, 0xD1835AU, 0xD19BB0U, 0xD1AA64U, 0xD1B28EU, 0xD1C9CCU, 0xD1D126U, 0xD1E0F2U, 0xD1F818U, + 0xD20B36U, 0xD213DCU, 0xD22208U, 0xD23AE2U, 0xD241A0U, 0xD2594AU, 0xD2689EU, 0xD27074U, 0xD286F0U, 0xD29E1AU, + 0xD2AFCEU, 0xD2B724U, 0xD2CC66U, 0xD2D48CU, 0xD2E558U, 0xD2FDB2U, 0xD30850U, 0xD310BAU, 0xD3216EU, 0xD33984U, + 0xD342C6U, 0xD35A2CU, 0xD36BF8U, 0xD37312U, 0xD38596U, 0xD39D7CU, 0xD3ACA8U, 0xD3B442U, 0xD3CF00U, 0xD3D7EAU, + 0xD3E63EU, 0xD3FED4U, 0xD40062U, 0xD41888U, 0xD4295CU, 0xD431B6U, 0xD44AF4U, 0xD4521EU, 0xD463CAU, 0xD47B20U, + 0xD48DA4U, 0xD4954EU, 0xD4A49AU, 0xD4BC70U, 0xD4C732U, 0xD4DFD8U, 0xD4EE0CU, 0xD4F6E6U, 0xD50304U, 0xD51BEEU, + 0xD52A3AU, 0xD532D0U, 0xD54992U, 0xD55178U, 0xD560ACU, 0xD57846U, 0xD58EC2U, 0xD59628U, 0xD5A7FCU, 0xD5BF16U, + 0xD5C454U, 0xD5DCBEU, 0xD5ED6AU, 0xD5F580U, 0xD606AEU, 0xD61E44U, 0xD62F90U, 0xD6377AU, 0xD64C38U, 0xD654D2U, + 0xD66506U, 0xD67DECU, 0xD68B68U, 0xD69382U, 0xD6A256U, 0xD6BABCU, 0xD6C1FEU, 0xD6D914U, 0xD6E8C0U, 0xD6F02AU, + 0xD705C8U, 0xD71D22U, 0xD72CF6U, 0xD7341CU, 0xD74F5EU, 0xD757B4U, 0xD76660U, 0xD77E8AU, 0xD7880EU, 0xD790E4U, + 0xD7A130U, 0xD7B9DAU, 0xD7C298U, 0xD7DA72U, 0xD7EBA6U, 0xD7F34CU, 0xD80E20U, 0xD816CAU, 0xD8271EU, 0xD83FF4U, + 0xD844B6U, 0xD85C5CU, 0xD86D88U, 0xD87562U, 0xD883E6U, 0xD89B0CU, 0xD8AAD8U, 0xD8B232U, 0xD8C970U, 0xD8D19AU, + 0xD8E04EU, 0xD8F8A4U, 0xD90D46U, 0xD915ACU, 0xD92478U, 0xD93C92U, 0xD947D0U, 0xD95F3AU, 0xD96EEEU, 0xD97604U, + 0xD98080U, 0xD9986AU, 0xD9A9BEU, 0xD9B154U, 0xD9CA16U, 0xD9D2FCU, 0xD9E328U, 0xD9FBC2U, 0xDA08ECU, 0xDA1006U, + 0xDA21D2U, 0xDA3938U, 0xDA427AU, 0xDA5A90U, 0xDA6B44U, 0xDA73AEU, 0xDA852AU, 0xDA9DC0U, 0xDAAC14U, 0xDAB4FEU, + 0xDACFBCU, 0xDAD756U, 0xDAE682U, 0xDAFE68U, 0xDB0B8AU, 0xDB1360U, 0xDB22B4U, 0xDB3A5EU, 0xDB411CU, 0xDB59F6U, + 0xDB6822U, 0xDB70C8U, 0xDB864CU, 0xDB9EA6U, 0xDBAF72U, 0xDBB798U, 0xDBCCDAU, 0xDBD430U, 0xDBE5E4U, 0xDBFD0EU, + 0xDC03B8U, 0xDC1B52U, 0xDC2A86U, 0xDC326CU, 0xDC492EU, 0xDC51C4U, 0xDC6010U, 0xDC78FAU, 0xDC8E7EU, 0xDC9694U, + 0xDCA740U, 0xDCBFAAU, 0xDCC4E8U, 0xDCDC02U, 0xDCEDD6U, 0xDCF53CU, 0xDD00DEU, 0xDD1834U, 0xDD29E0U, 0xDD310AU, + 0xDD4A48U, 0xDD52A2U, 0xDD6376U, 0xDD7B9CU, 0xDD8D18U, 0xDD95F2U, 0xDDA426U, 0xDDBCCCU, 0xDDC78EU, 0xDDDF64U, + 0xDDEEB0U, 0xDDF65AU, 0xDE0574U, 0xDE1D9EU, 0xDE2C4AU, 0xDE34A0U, 0xDE4FE2U, 0xDE5708U, 0xDE66DCU, 0xDE7E36U, + 0xDE88B2U, 0xDE9058U, 0xDEA18CU, 0xDEB966U, 0xDEC224U, 0xDEDACEU, 0xDEEB1AU, 0xDEF3F0U, 0xDF0612U, 0xDF1EF8U, + 0xDF2F2CU, 0xDF37C6U, 0xDF4C84U, 0xDF546EU, 0xDF65BAU, 0xDF7D50U, 0xDF8BD4U, 0xDF933EU, 0xDFA2EAU, 0xDFBA00U, + 0xDFC142U, 0xDFD9A8U, 0xDFE87CU, 0xDFF096U, 0xE00526U, 0xE01DCCU, 0xE02C18U, 0xE034F2U, 0xE04FB0U, 0xE0575AU, + 0xE0668EU, 0xE07E64U, 0xE088E0U, 0xE0900AU, 0xE0A1DEU, 0xE0B934U, 0xE0C276U, 0xE0DA9CU, 0xE0EB48U, 0xE0F3A2U, + 0xE10640U, 0xE11EAAU, 0xE12F7EU, 0xE13794U, 0xE14CD6U, 0xE1543CU, 0xE165E8U, 0xE17D02U, 0xE18B86U, 0xE1936CU, + 0xE1A2B8U, 0xE1BA52U, 0xE1C110U, 0xE1D9FAU, 0xE1E82EU, 0xE1F0C4U, 0xE203EAU, 0xE21B00U, 0xE22AD4U, 0xE2323EU, + 0xE2497CU, 0xE25196U, 0xE26042U, 0xE278A8U, 0xE28E2CU, 0xE296C6U, 0xE2A712U, 0xE2BFF8U, 0xE2C4BAU, 0xE2DC50U, + 0xE2ED84U, 0xE2F56EU, 0xE3008CU, 0xE31866U, 0xE329B2U, 0xE33158U, 0xE34A1AU, 0xE352F0U, 0xE36324U, 0xE37BCEU, + 0xE38D4AU, 0xE395A0U, 0xE3A474U, 0xE3BC9EU, 0xE3C7DCU, 0xE3DF36U, 0xE3EEE2U, 0xE3F608U, 0xE408BEU, 0xE41054U, + 0xE42180U, 0xE4396AU, 0xE44228U, 0xE45AC2U, 0xE46B16U, 0xE473FCU, 0xE48578U, 0xE49D92U, 0xE4AC46U, 0xE4B4ACU, + 0xE4CFEEU, 0xE4D704U, 0xE4E6D0U, 0xE4FE3AU, 0xE50BD8U, 0xE51332U, 0xE522E6U, 0xE53A0CU, 0xE5414EU, 0xE559A4U, + 0xE56870U, 0xE5709AU, 0xE5861EU, 0xE59EF4U, 0xE5AF20U, 0xE5B7CAU, 0xE5CC88U, 0xE5D462U, 0xE5E5B6U, 0xE5FD5CU, + 0xE60E72U, 0xE61698U, 0xE6274CU, 0xE63FA6U, 0xE644E4U, 0xE65C0EU, 0xE66DDAU, 0xE67530U, 0xE683B4U, 0xE69B5EU, + 0xE6AA8AU, 0xE6B260U, 0xE6C922U, 0xE6D1C8U, 0xE6E01CU, 0xE6F8F6U, 0xE70D14U, 0xE715FEU, 0xE7242AU, 0xE73CC0U, + 0xE74782U, 0xE75F68U, 0xE76EBCU, 0xE77656U, 0xE780D2U, 0xE79838U, 0xE7A9ECU, 0xE7B106U, 0xE7CA44U, 0xE7D2AEU, + 0xE7E37AU, 0xE7FB90U, 0xE806FCU, 0xE81E16U, 0xE82FC2U, 0xE83728U, 0xE84C6AU, 0xE85480U, 0xE86554U, 0xE87DBEU, + 0xE88B3AU, 0xE893D0U, 0xE8A204U, 0xE8BAEEU, 0xE8C1ACU, 0xE8D946U, 0xE8E892U, 0xE8F078U, 0xE9059AU, 0xE91D70U, + 0xE92CA4U, 0xE9344EU, 0xE94F0CU, 0xE957E6U, 0xE96632U, 0xE97ED8U, 0xE9885CU, 0xE990B6U, 0xE9A162U, 0xE9B988U, + 0xE9C2CAU, 0xE9DA20U, 0xE9EBF4U, 0xE9F31EU, 0xEA0030U, 0xEA18DAU, 0xEA290EU, 0xEA31E4U, 0xEA4AA6U, 0xEA524CU, + 0xEA6398U, 0xEA7B72U, 0xEA8DF6U, 0xEA951CU, 0xEAA4C8U, 0xEABC22U, 0xEAC760U, 0xEADF8AU, 0xEAEE5EU, 0xEAF6B4U, + 0xEB0356U, 0xEB1BBCU, 0xEB2A68U, 0xEB3282U, 0xEB49C0U, 0xEB512AU, 0xEB60FEU, 0xEB7814U, 0xEB8E90U, 0xEB967AU, + 0xEBA7AEU, 0xEBBF44U, 0xEBC406U, 0xEBDCECU, 0xEBED38U, 0xEBF5D2U, 0xEC0B64U, 0xEC138EU, 0xEC225AU, 0xEC3AB0U, + 0xEC41F2U, 0xEC5918U, 0xEC68CCU, 0xEC7026U, 0xEC86A2U, 0xEC9E48U, 0xECAF9CU, 0xECB776U, 0xECCC34U, 0xECD4DEU, + 0xECE50AU, 0xECFDE0U, 0xED0802U, 0xED10E8U, 0xED213CU, 0xED39D6U, 0xED4294U, 0xED5A7EU, 0xED6BAAU, 0xED7340U, + 0xED85C4U, 0xED9D2EU, 0xEDACFAU, 0xEDB410U, 0xEDCF52U, 0xEDD7B8U, 0xEDE66CU, 0xEDFE86U, 0xEE0DA8U, 0xEE1542U, + 0xEE2496U, 0xEE3C7CU, 0xEE473EU, 0xEE5FD4U, 0xEE6E00U, 0xEE76EAU, 0xEE806EU, 0xEE9884U, 0xEEA950U, 0xEEB1BAU, + 0xEECAF8U, 0xEED212U, 0xEEE3C6U, 0xEEFB2CU, 0xEF0ECEU, 0xEF1624U, 0xEF27F0U, 0xEF3F1AU, 0xEF4458U, 0xEF5CB2U, + 0xEF6D66U, 0xEF758CU, 0xEF8308U, 0xEF9BE2U, 0xEFAA36U, 0xEFB2DCU, 0xEFC99EU, 0xEFD174U, 0xEFE0A0U, 0xEFF84AU, + 0xF00292U, 0xF01A78U, 0xF02BACU, 0xF03346U, 0xF04804U, 0xF050EEU, 0xF0613AU, 0xF079D0U, 0xF08F54U, 0xF097BEU, + 0xF0A66AU, 0xF0BE80U, 0xF0C5C2U, 0xF0DD28U, 0xF0ECFCU, 0xF0F416U, 0xF101F4U, 0xF1191EU, 0xF128CAU, 0xF13020U, + 0xF14B62U, 0xF15388U, 0xF1625CU, 0xF17AB6U, 0xF18C32U, 0xF194D8U, 0xF1A50CU, 0xF1BDE6U, 0xF1C6A4U, 0xF1DE4EU, + 0xF1EF9AU, 0xF1F770U, 0xF2045EU, 0xF21CB4U, 0xF22D60U, 0xF2358AU, 0xF24EC8U, 0xF25622U, 0xF267F6U, 0xF27F1CU, + 0xF28998U, 0xF29172U, 0xF2A0A6U, 0xF2B84CU, 0xF2C30EU, 0xF2DBE4U, 0xF2EA30U, 0xF2F2DAU, 0xF30738U, 0xF31FD2U, + 0xF32E06U, 0xF336ECU, 0xF34DAEU, 0xF35544U, 0xF36490U, 0xF37C7AU, 0xF38AFEU, 0xF39214U, 0xF3A3C0U, 0xF3BB2AU, + 0xF3C068U, 0xF3D882U, 0xF3E956U, 0xF3F1BCU, 0xF40F0AU, 0xF417E0U, 0xF42634U, 0xF43EDEU, 0xF4459CU, 0xF45D76U, + 0xF46CA2U, 0xF47448U, 0xF482CCU, 0xF49A26U, 0xF4ABF2U, 0xF4B318U, 0xF4C85AU, 0xF4D0B0U, 0xF4E164U, 0xF4F98EU, + 0xF50C6CU, 0xF51486U, 0xF52552U, 0xF53DB8U, 0xF546FAU, 0xF55E10U, 0xF56FC4U, 0xF5772EU, 0xF581AAU, 0xF59940U, + 0xF5A894U, 0xF5B07EU, 0xF5CB3CU, 0xF5D3D6U, 0xF5E202U, 0xF5FAE8U, 0xF609C6U, 0xF6112CU, 0xF620F8U, 0xF63812U, + 0xF64350U, 0xF65BBAU, 0xF66A6EU, 0xF67284U, 0xF68400U, 0xF69CEAU, 0xF6AD3EU, 0xF6B5D4U, 0xF6CE96U, 0xF6D67CU, + 0xF6E7A8U, 0xF6FF42U, 0xF70AA0U, 0xF7124AU, 0xF7239EU, 0xF73B74U, 0xF74036U, 0xF758DCU, 0xF76908U, 0xF771E2U, + 0xF78766U, 0xF79F8CU, 0xF7AE58U, 0xF7B6B2U, 0xF7CDF0U, 0xF7D51AU, 0xF7E4CEU, 0xF7FC24U, 0xF80148U, 0xF819A2U, + 0xF82876U, 0xF8309CU, 0xF84BDEU, 0xF85334U, 0xF862E0U, 0xF87A0AU, 0xF88C8EU, 0xF89464U, 0xF8A5B0U, 0xF8BD5AU, + 0xF8C618U, 0xF8DEF2U, 0xF8EF26U, 0xF8F7CCU, 0xF9022EU, 0xF91AC4U, 0xF92B10U, 0xF933FAU, 0xF948B8U, 0xF95052U, + 0xF96186U, 0xF9796CU, 0xF98FE8U, 0xF99702U, 0xF9A6D6U, 0xF9BE3CU, 0xF9C57EU, 0xF9DD94U, 0xF9EC40U, 0xF9F4AAU, + 0xFA0784U, 0xFA1F6EU, 0xFA2EBAU, 0xFA3650U, 0xFA4D12U, 0xFA55F8U, 0xFA642CU, 0xFA7CC6U, 0xFA8A42U, 0xFA92A8U, + 0xFAA37CU, 0xFABB96U, 0xFAC0D4U, 0xFAD83EU, 0xFAE9EAU, 0xFAF100U, 0xFB04E2U, 0xFB1C08U, 0xFB2DDCU, 0xFB3536U, + 0xFB4E74U, 0xFB569EU, 0xFB674AU, 0xFB7FA0U, 0xFB8924U, 0xFB91CEU, 0xFBA01AU, 0xFBB8F0U, 0xFBC3B2U, 0xFBDB58U, + 0xFBEA8CU, 0xFBF266U, 0xFC0CD0U, 0xFC143AU, 0xFC25EEU, 0xFC3D04U, 0xFC4646U, 0xFC5EACU, 0xFC6F78U, 0xFC7792U, + 0xFC8116U, 0xFC99FCU, 0xFCA828U, 0xFCB0C2U, 0xFCCB80U, 0xFCD36AU, 0xFCE2BEU, 0xFCFA54U, 0xFD0FB6U, 0xFD175CU, + 0xFD2688U, 0xFD3E62U, 0xFD4520U, 0xFD5DCAU, 0xFD6C1EU, 0xFD74F4U, 0xFD8270U, 0xFD9A9AU, 0xFDAB4EU, 0xFDB3A4U, + 0xFDC8E6U, 0xFDD00CU, 0xFDE1D8U, 0xFDF932U, 0xFE0A1CU, 0xFE12F6U, 0xFE2322U, 0xFE3BC8U, 0xFE408AU, 0xFE5860U, + 0xFE69B4U, 0xFE715EU, 0xFE87DAU, 0xFE9F30U, 0xFEAEE4U, 0xFEB60EU, 0xFECD4CU, 0xFED5A6U, 0xFEE472U, 0xFEFC98U, + 0xFF097AU, 0xFF1190U, 0xFF2044U, 0xFF38AEU, 0xFF43ECU, 0xFF5B06U, 0xFF6AD2U, 0xFF7238U, 0xFF84BCU, 0xFF9C56U, + 0xFFAD82U, 0xFFB568U, 0xFFCE2AU, 0xFFD6C0U, 0xFFE714U, 0xFFFFFEU}; + +static const unsigned int ENCODING_TABLE_24128[] = { + 0x000000U, 0x0018EBU, 0x00293EU, 0x0031D5U, 0x004A97U, 0x00527CU, 0x0063A9U, 0x007B42U, 0x008DC6U, 0x00952DU, + 0x00A4F8U, 0x00BC13U, 0x00C751U, 0x00DFBAU, 0x00EE6FU, 0x00F684U, 0x010367U, 0x011B8CU, 0x012A59U, 0x0132B2U, + 0x0149F0U, 0x01511BU, 0x0160CEU, 0x017825U, 0x018EA1U, 0x01964AU, 0x01A79FU, 0x01BF74U, 0x01C436U, 0x01DCDDU, + 0x01ED08U, 0x01F5E3U, 0x0206CDU, 0x021E26U, 0x022FF3U, 0x023718U, 0x024C5AU, 0x0254B1U, 0x026564U, 0x027D8FU, + 0x028B0BU, 0x0293E0U, 0x02A235U, 0x02BADEU, 0x02C19CU, 0x02D977U, 0x02E8A2U, 0x02F049U, 0x0305AAU, 0x031D41U, + 0x032C94U, 0x03347FU, 0x034F3DU, 0x0357D6U, 0x036603U, 0x037EE8U, 0x03886CU, 0x039087U, 0x03A152U, 0x03B9B9U, + 0x03C2FBU, 0x03DA10U, 0x03EBC5U, 0x03F32EU, 0x040D99U, 0x041572U, 0x0424A7U, 0x043C4CU, 0x04470EU, 0x045FE5U, + 0x046E30U, 0x0476DBU, 0x04805FU, 0x0498B4U, 0x04A961U, 0x04B18AU, 0x04CAC8U, 0x04D223U, 0x04E3F6U, 0x04FB1DU, + 0x050EFEU, 0x051615U, 0x0527C0U, 0x053F2BU, 0x054469U, 0x055C82U, 0x056D57U, 0x0575BCU, 0x058338U, 0x059BD3U, + 0x05AA06U, 0x05B2EDU, 0x05C9AFU, 0x05D144U, 0x05E091U, 0x05F87AU, 0x060B54U, 0x0613BFU, 0x06226AU, 0x063A81U, + 0x0641C3U, 0x065928U, 0x0668FDU, 0x067016U, 0x068692U, 0x069E79U, 0x06AFACU, 0x06B747U, 0x06CC05U, 0x06D4EEU, + 0x06E53BU, 0x06FDD0U, 0x070833U, 0x0710D8U, 0x07210DU, 0x0739E6U, 0x0742A4U, 0x075A4FU, 0x076B9AU, 0x077371U, + 0x0785F5U, 0x079D1EU, 0x07ACCBU, 0x07B420U, 0x07CF62U, 0x07D789U, 0x07E65CU, 0x07FEB7U, 0x0803DAU, 0x081B31U, + 0x082AE4U, 0x08320FU, 0x08494DU, 0x0851A6U, 0x086073U, 0x087898U, 0x088E1CU, 0x0896F7U, 0x08A722U, 0x08BFC9U, + 0x08C48BU, 0x08DC60U, 0x08EDB5U, 0x08F55EU, 0x0900BDU, 0x091856U, 0x092983U, 0x093168U, 0x094A2AU, 0x0952C1U, + 0x096314U, 0x097BFFU, 0x098D7BU, 0x099590U, 0x09A445U, 0x09BCAEU, 0x09C7ECU, 0x09DF07U, 0x09EED2U, 0x09F639U, + 0x0A0517U, 0x0A1DFCU, 0x0A2C29U, 0x0A34C2U, 0x0A4F80U, 0x0A576BU, 0x0A66BEU, 0x0A7E55U, 0x0A88D1U, 0x0A903AU, + 0x0AA1EFU, 0x0AB904U, 0x0AC246U, 0x0ADAADU, 0x0AEB78U, 0x0AF393U, 0x0B0670U, 0x0B1E9BU, 0x0B2F4EU, 0x0B37A5U, + 0x0B4CE7U, 0x0B540CU, 0x0B65D9U, 0x0B7D32U, 0x0B8BB6U, 0x0B935DU, 0x0BA288U, 0x0BBA63U, 0x0BC121U, 0x0BD9CAU, + 0x0BE81FU, 0x0BF0F4U, 0x0C0E43U, 0x0C16A8U, 0x0C277DU, 0x0C3F96U, 0x0C44D4U, 0x0C5C3FU, 0x0C6DEAU, 0x0C7501U, + 0x0C8385U, 0x0C9B6EU, 0x0CAABBU, 0x0CB250U, 0x0CC912U, 0x0CD1F9U, 0x0CE02CU, 0x0CF8C7U, 0x0D0D24U, 0x0D15CFU, + 0x0D241AU, 0x0D3CF1U, 0x0D47B3U, 0x0D5F58U, 0x0D6E8DU, 0x0D7666U, 0x0D80E2U, 0x0D9809U, 0x0DA9DCU, 0x0DB137U, + 0x0DCA75U, 0x0DD29EU, 0x0DE34BU, 0x0DFBA0U, 0x0E088EU, 0x0E1065U, 0x0E21B0U, 0x0E395BU, 0x0E4219U, 0x0E5AF2U, + 0x0E6B27U, 0x0E73CCU, 0x0E8548U, 0x0E9DA3U, 0x0EAC76U, 0x0EB49DU, 0x0ECFDFU, 0x0ED734U, 0x0EE6E1U, 0x0EFE0AU, + 0x0F0BE9U, 0x0F1302U, 0x0F22D7U, 0x0F3A3CU, 0x0F417EU, 0x0F5995U, 0x0F6840U, 0x0F70ABU, 0x0F862FU, 0x0F9EC4U, + 0x0FAF11U, 0x0FB7FAU, 0x0FCCB8U, 0x0FD453U, 0x0FE586U, 0x0FFD6DU, 0x1007B4U, 0x101F5FU, 0x102E8AU, 0x103661U, + 0x104D23U, 0x1055C8U, 0x10641DU, 0x107CF6U, 0x108A72U, 0x109299U, 0x10A34CU, 0x10BBA7U, 0x10C0E5U, 0x10D80EU, + 0x10E9DBU, 0x10F130U, 0x1104D3U, 0x111C38U, 0x112DEDU, 0x113506U, 0x114E44U, 0x1156AFU, 0x11677AU, 0x117F91U, + 0x118915U, 0x1191FEU, 0x11A02BU, 0x11B8C0U, 0x11C382U, 0x11DB69U, 0x11EABCU, 0x11F257U, 0x120179U, 0x121992U, + 0x122847U, 0x1230ACU, 0x124BEEU, 0x125305U, 0x1262D0U, 0x127A3BU, 0x128CBFU, 0x129454U, 0x12A581U, 0x12BD6AU, + 0x12C628U, 0x12DEC3U, 0x12EF16U, 0x12F7FDU, 0x13021EU, 0x131AF5U, 0x132B20U, 0x1333CBU, 0x134889U, 0x135062U, + 0x1361B7U, 0x13795CU, 0x138FD8U, 0x139733U, 0x13A6E6U, 0x13BE0DU, 0x13C54FU, 0x13DDA4U, 0x13EC71U, 0x13F49AU, + 0x140A2DU, 0x1412C6U, 0x142313U, 0x143BF8U, 0x1440BAU, 0x145851U, 0x146984U, 0x14716FU, 0x1487EBU, 0x149F00U, + 0x14AED5U, 0x14B63EU, 0x14CD7CU, 0x14D597U, 0x14E442U, 0x14FCA9U, 0x15094AU, 0x1511A1U, 0x152074U, 0x15389FU, + 0x1543DDU, 0x155B36U, 0x156AE3U, 0x157208U, 0x15848CU, 0x159C67U, 0x15ADB2U, 0x15B559U, 0x15CE1BU, 0x15D6F0U, + 0x15E725U, 0x15FFCEU, 0x160CE0U, 0x16140BU, 0x1625DEU, 0x163D35U, 0x164677U, 0x165E9CU, 0x166F49U, 0x1677A2U, + 0x168126U, 0x1699CDU, 0x16A818U, 0x16B0F3U, 0x16CBB1U, 0x16D35AU, 0x16E28FU, 0x16FA64U, 0x170F87U, 0x17176CU, + 0x1726B9U, 0x173E52U, 0x174510U, 0x175DFBU, 0x176C2EU, 0x1774C5U, 0x178241U, 0x179AAAU, 0x17AB7FU, 0x17B394U, + 0x17C8D6U, 0x17D03DU, 0x17E1E8U, 0x17F903U, 0x18046EU, 0x181C85U, 0x182D50U, 0x1835BBU, 0x184EF9U, 0x185612U, + 0x1867C7U, 0x187F2CU, 0x1889A8U, 0x189143U, 0x18A096U, 0x18B87DU, 0x18C33FU, 0x18DBD4U, 0x18EA01U, 0x18F2EAU, + 0x190709U, 0x191FE2U, 0x192E37U, 0x1936DCU, 0x194D9EU, 0x195575U, 0x1964A0U, 0x197C4BU, 0x198ACFU, 0x199224U, + 0x19A3F1U, 0x19BB1AU, 0x19C058U, 0x19D8B3U, 0x19E966U, 0x19F18DU, 0x1A02A3U, 0x1A1A48U, 0x1A2B9DU, 0x1A3376U, + 0x1A4834U, 0x1A50DFU, 0x1A610AU, 0x1A79E1U, 0x1A8F65U, 0x1A978EU, 0x1AA65BU, 0x1ABEB0U, 0x1AC5F2U, 0x1ADD19U, + 0x1AECCCU, 0x1AF427U, 0x1B01C4U, 0x1B192FU, 0x1B28FAU, 0x1B3011U, 0x1B4B53U, 0x1B53B8U, 0x1B626DU, 0x1B7A86U, + 0x1B8C02U, 0x1B94E9U, 0x1BA53CU, 0x1BBDD7U, 0x1BC695U, 0x1BDE7EU, 0x1BEFABU, 0x1BF740U, 0x1C09F7U, 0x1C111CU, + 0x1C20C9U, 0x1C3822U, 0x1C4360U, 0x1C5B8BU, 0x1C6A5EU, 0x1C72B5U, 0x1C8431U, 0x1C9CDAU, 0x1CAD0FU, 0x1CB5E4U, + 0x1CCEA6U, 0x1CD64DU, 0x1CE798U, 0x1CFF73U, 0x1D0A90U, 0x1D127BU, 0x1D23AEU, 0x1D3B45U, 0x1D4007U, 0x1D58ECU, + 0x1D6939U, 0x1D71D2U, 0x1D8756U, 0x1D9FBDU, 0x1DAE68U, 0x1DB683U, 0x1DCDC1U, 0x1DD52AU, 0x1DE4FFU, 0x1DFC14U, + 0x1E0F3AU, 0x1E17D1U, 0x1E2604U, 0x1E3EEFU, 0x1E45ADU, 0x1E5D46U, 0x1E6C93U, 0x1E7478U, 0x1E82FCU, 0x1E9A17U, + 0x1EABC2U, 0x1EB329U, 0x1EC86BU, 0x1ED080U, 0x1EE155U, 0x1EF9BEU, 0x1F0C5DU, 0x1F14B6U, 0x1F2563U, 0x1F3D88U, + 0x1F46CAU, 0x1F5E21U, 0x1F6FF4U, 0x1F771FU, 0x1F819BU, 0x1F9970U, 0x1FA8A5U, 0x1FB04EU, 0x1FCB0CU, 0x1FD3E7U, + 0x1FE232U, 0x1FFAD9U, 0x200F68U, 0x201783U, 0x202656U, 0x203EBDU, 0x2045FFU, 0x205D14U, 0x206CC1U, 0x20742AU, + 0x2082AEU, 0x209A45U, 0x20AB90U, 0x20B37BU, 0x20C839U, 0x20D0D2U, 0x20E107U, 0x20F9ECU, 0x210C0FU, 0x2114E4U, + 0x212531U, 0x213DDAU, 0x214698U, 0x215E73U, 0x216FA6U, 0x21774DU, 0x2181C9U, 0x219922U, 0x21A8F7U, 0x21B01CU, + 0x21CB5EU, 0x21D3B5U, 0x21E260U, 0x21FA8BU, 0x2209A5U, 0x22114EU, 0x22209BU, 0x223870U, 0x224332U, 0x225BD9U, + 0x226A0CU, 0x2272E7U, 0x228463U, 0x229C88U, 0x22AD5DU, 0x22B5B6U, 0x22CEF4U, 0x22D61FU, 0x22E7CAU, 0x22FF21U, + 0x230AC2U, 0x231229U, 0x2323FCU, 0x233B17U, 0x234055U, 0x2358BEU, 0x23696BU, 0x237180U, 0x238704U, 0x239FEFU, + 0x23AE3AU, 0x23B6D1U, 0x23CD93U, 0x23D578U, 0x23E4ADU, 0x23FC46U, 0x2402F1U, 0x241A1AU, 0x242BCFU, 0x243324U, + 0x244866U, 0x24508DU, 0x246158U, 0x2479B3U, 0x248F37U, 0x2497DCU, 0x24A609U, 0x24BEE2U, 0x24C5A0U, 0x24DD4BU, + 0x24EC9EU, 0x24F475U, 0x250196U, 0x25197DU, 0x2528A8U, 0x253043U, 0x254B01U, 0x2553EAU, 0x25623FU, 0x257AD4U, + 0x258C50U, 0x2594BBU, 0x25A56EU, 0x25BD85U, 0x25C6C7U, 0x25DE2CU, 0x25EFF9U, 0x25F712U, 0x26043CU, 0x261CD7U, + 0x262D02U, 0x2635E9U, 0x264EABU, 0x265640U, 0x266795U, 0x267F7EU, 0x2689FAU, 0x269111U, 0x26A0C4U, 0x26B82FU, + 0x26C36DU, 0x26DB86U, 0x26EA53U, 0x26F2B8U, 0x27075BU, 0x271FB0U, 0x272E65U, 0x27368EU, 0x274DCCU, 0x275527U, + 0x2764F2U, 0x277C19U, 0x278A9DU, 0x279276U, 0x27A3A3U, 0x27BB48U, 0x27C00AU, 0x27D8E1U, 0x27E934U, 0x27F1DFU, + 0x280CB2U, 0x281459U, 0x28258CU, 0x283D67U, 0x284625U, 0x285ECEU, 0x286F1BU, 0x2877F0U, 0x288174U, 0x28999FU, + 0x28A84AU, 0x28B0A1U, 0x28CBE3U, 0x28D308U, 0x28E2DDU, 0x28FA36U, 0x290FD5U, 0x29173EU, 0x2926EBU, 0x293E00U, + 0x294542U, 0x295DA9U, 0x296C7CU, 0x297497U, 0x298213U, 0x299AF8U, 0x29AB2DU, 0x29B3C6U, 0x29C884U, 0x29D06FU, + 0x29E1BAU, 0x29F951U, 0x2A0A7FU, 0x2A1294U, 0x2A2341U, 0x2A3BAAU, 0x2A40E8U, 0x2A5803U, 0x2A69D6U, 0x2A713DU, + 0x2A87B9U, 0x2A9F52U, 0x2AAE87U, 0x2AB66CU, 0x2ACD2EU, 0x2AD5C5U, 0x2AE410U, 0x2AFCFBU, 0x2B0918U, 0x2B11F3U, + 0x2B2026U, 0x2B38CDU, 0x2B438FU, 0x2B5B64U, 0x2B6AB1U, 0x2B725AU, 0x2B84DEU, 0x2B9C35U, 0x2BADE0U, 0x2BB50BU, + 0x2BCE49U, 0x2BD6A2U, 0x2BE777U, 0x2BFF9CU, 0x2C012BU, 0x2C19C0U, 0x2C2815U, 0x2C30FEU, 0x2C4BBCU, 0x2C5357U, + 0x2C6282U, 0x2C7A69U, 0x2C8CEDU, 0x2C9406U, 0x2CA5D3U, 0x2CBD38U, 0x2CC67AU, 0x2CDE91U, 0x2CEF44U, 0x2CF7AFU, + 0x2D024CU, 0x2D1AA7U, 0x2D2B72U, 0x2D3399U, 0x2D48DBU, 0x2D5030U, 0x2D61E5U, 0x2D790EU, 0x2D8F8AU, 0x2D9761U, + 0x2DA6B4U, 0x2DBE5FU, 0x2DC51DU, 0x2DDDF6U, 0x2DEC23U, 0x2DF4C8U, 0x2E07E6U, 0x2E1F0DU, 0x2E2ED8U, 0x2E3633U, + 0x2E4D71U, 0x2E559AU, 0x2E644FU, 0x2E7CA4U, 0x2E8A20U, 0x2E92CBU, 0x2EA31EU, 0x2EBBF5U, 0x2EC0B7U, 0x2ED85CU, + 0x2EE989U, 0x2EF162U, 0x2F0481U, 0x2F1C6AU, 0x2F2DBFU, 0x2F3554U, 0x2F4E16U, 0x2F56FDU, 0x2F6728U, 0x2F7FC3U, + 0x2F8947U, 0x2F91ACU, 0x2FA079U, 0x2FB892U, 0x2FC3D0U, 0x2FDB3BU, 0x2FEAEEU, 0x2FF205U, 0x3008DCU, 0x301037U, + 0x3021E2U, 0x303909U, 0x30424BU, 0x305AA0U, 0x306B75U, 0x30739EU, 0x30851AU, 0x309DF1U, 0x30AC24U, 0x30B4CFU, + 0x30CF8DU, 0x30D766U, 0x30E6B3U, 0x30FE58U, 0x310BBBU, 0x311350U, 0x312285U, 0x313A6EU, 0x31412CU, 0x3159C7U, + 0x316812U, 0x3170F9U, 0x31867DU, 0x319E96U, 0x31AF43U, 0x31B7A8U, 0x31CCEAU, 0x31D401U, 0x31E5D4U, 0x31FD3FU, + 0x320E11U, 0x3216FAU, 0x32272FU, 0x323FC4U, 0x324486U, 0x325C6DU, 0x326DB8U, 0x327553U, 0x3283D7U, 0x329B3CU, + 0x32AAE9U, 0x32B202U, 0x32C940U, 0x32D1ABU, 0x32E07EU, 0x32F895U, 0x330D76U, 0x33159DU, 0x332448U, 0x333CA3U, + 0x3347E1U, 0x335F0AU, 0x336EDFU, 0x337634U, 0x3380B0U, 0x33985BU, 0x33A98EU, 0x33B165U, 0x33CA27U, 0x33D2CCU, + 0x33E319U, 0x33FBF2U, 0x340545U, 0x341DAEU, 0x342C7BU, 0x343490U, 0x344FD2U, 0x345739U, 0x3466ECU, 0x347E07U, + 0x348883U, 0x349068U, 0x34A1BDU, 0x34B956U, 0x34C214U, 0x34DAFFU, 0x34EB2AU, 0x34F3C1U, 0x350622U, 0x351EC9U, + 0x352F1CU, 0x3537F7U, 0x354CB5U, 0x35545EU, 0x35658BU, 0x357D60U, 0x358BE4U, 0x35930FU, 0x35A2DAU, 0x35BA31U, + 0x35C173U, 0x35D998U, 0x35E84DU, 0x35F0A6U, 0x360388U, 0x361B63U, 0x362AB6U, 0x36325DU, 0x36491FU, 0x3651F4U, + 0x366021U, 0x3678CAU, 0x368E4EU, 0x3696A5U, 0x36A770U, 0x36BF9BU, 0x36C4D9U, 0x36DC32U, 0x36EDE7U, 0x36F50CU, + 0x3700EFU, 0x371804U, 0x3729D1U, 0x37313AU, 0x374A78U, 0x375293U, 0x376346U, 0x377BADU, 0x378D29U, 0x3795C2U, + 0x37A417U, 0x37BCFCU, 0x37C7BEU, 0x37DF55U, 0x37EE80U, 0x37F66BU, 0x380B06U, 0x3813EDU, 0x382238U, 0x383AD3U, + 0x384191U, 0x38597AU, 0x3868AFU, 0x387044U, 0x3886C0U, 0x389E2BU, 0x38AFFEU, 0x38B715U, 0x38CC57U, 0x38D4BCU, + 0x38E569U, 0x38FD82U, 0x390861U, 0x39108AU, 0x39215FU, 0x3939B4U, 0x3942F6U, 0x395A1DU, 0x396BC8U, 0x397323U, + 0x3985A7U, 0x399D4CU, 0x39AC99U, 0x39B472U, 0x39CF30U, 0x39D7DBU, 0x39E60EU, 0x39FEE5U, 0x3A0DCBU, 0x3A1520U, + 0x3A24F5U, 0x3A3C1EU, 0x3A475CU, 0x3A5FB7U, 0x3A6E62U, 0x3A7689U, 0x3A800DU, 0x3A98E6U, 0x3AA933U, 0x3AB1D8U, + 0x3ACA9AU, 0x3AD271U, 0x3AE3A4U, 0x3AFB4FU, 0x3B0EACU, 0x3B1647U, 0x3B2792U, 0x3B3F79U, 0x3B443BU, 0x3B5CD0U, + 0x3B6D05U, 0x3B75EEU, 0x3B836AU, 0x3B9B81U, 0x3BAA54U, 0x3BB2BFU, 0x3BC9FDU, 0x3BD116U, 0x3BE0C3U, 0x3BF828U, + 0x3C069FU, 0x3C1E74U, 0x3C2FA1U, 0x3C374AU, 0x3C4C08U, 0x3C54E3U, 0x3C6536U, 0x3C7DDDU, 0x3C8B59U, 0x3C93B2U, + 0x3CA267U, 0x3CBA8CU, 0x3CC1CEU, 0x3CD925U, 0x3CE8F0U, 0x3CF01BU, 0x3D05F8U, 0x3D1D13U, 0x3D2CC6U, 0x3D342DU, + 0x3D4F6FU, 0x3D5784U, 0x3D6651U, 0x3D7EBAU, 0x3D883EU, 0x3D90D5U, 0x3DA100U, 0x3DB9EBU, 0x3DC2A9U, 0x3DDA42U, + 0x3DEB97U, 0x3DF37CU, 0x3E0052U, 0x3E18B9U, 0x3E296CU, 0x3E3187U, 0x3E4AC5U, 0x3E522EU, 0x3E63FBU, 0x3E7B10U, + 0x3E8D94U, 0x3E957FU, 0x3EA4AAU, 0x3EBC41U, 0x3EC703U, 0x3EDFE8U, 0x3EEE3DU, 0x3EF6D6U, 0x3F0335U, 0x3F1BDEU, + 0x3F2A0BU, 0x3F32E0U, 0x3F49A2U, 0x3F5149U, 0x3F609CU, 0x3F7877U, 0x3F8EF3U, 0x3F9618U, 0x3FA7CDU, 0x3FBF26U, + 0x3FC464U, 0x3FDC8FU, 0x3FED5AU, 0x3FF5B1U, 0x40063BU, 0x401ED0U, 0x402F05U, 0x4037EEU, 0x404CACU, 0x405447U, + 0x406592U, 0x407D79U, 0x408BFDU, 0x409316U, 0x40A2C3U, 0x40BA28U, 0x40C16AU, 0x40D981U, 0x40E854U, 0x40F0BFU, + 0x41055CU, 0x411DB7U, 0x412C62U, 0x413489U, 0x414FCBU, 0x415720U, 0x4166F5U, 0x417E1EU, 0x41889AU, 0x419071U, + 0x41A1A4U, 0x41B94FU, 0x41C20DU, 0x41DAE6U, 0x41EB33U, 0x41F3D8U, 0x4200F6U, 0x42181DU, 0x4229C8U, 0x423123U, + 0x424A61U, 0x42528AU, 0x42635FU, 0x427BB4U, 0x428D30U, 0x4295DBU, 0x42A40EU, 0x42BCE5U, 0x42C7A7U, 0x42DF4CU, + 0x42EE99U, 0x42F672U, 0x430391U, 0x431B7AU, 0x432AAFU, 0x433244U, 0x434906U, 0x4351EDU, 0x436038U, 0x4378D3U, + 0x438E57U, 0x4396BCU, 0x43A769U, 0x43BF82U, 0x43C4C0U, 0x43DC2BU, 0x43EDFEU, 0x43F515U, 0x440BA2U, 0x441349U, + 0x44229CU, 0x443A77U, 0x444135U, 0x4459DEU, 0x44680BU, 0x4470E0U, 0x448664U, 0x449E8FU, 0x44AF5AU, 0x44B7B1U, + 0x44CCF3U, 0x44D418U, 0x44E5CDU, 0x44FD26U, 0x4508C5U, 0x45102EU, 0x4521FBU, 0x453910U, 0x454252U, 0x455AB9U, + 0x456B6CU, 0x457387U, 0x458503U, 0x459DE8U, 0x45AC3DU, 0x45B4D6U, 0x45CF94U, 0x45D77FU, 0x45E6AAU, 0x45FE41U, + 0x460D6FU, 0x461584U, 0x462451U, 0x463CBAU, 0x4647F8U, 0x465F13U, 0x466EC6U, 0x46762DU, 0x4680A9U, 0x469842U, + 0x46A997U, 0x46B17CU, 0x46CA3EU, 0x46D2D5U, 0x46E300U, 0x46FBEBU, 0x470E08U, 0x4716E3U, 0x472736U, 0x473FDDU, + 0x47449FU, 0x475C74U, 0x476DA1U, 0x47754AU, 0x4783CEU, 0x479B25U, 0x47AAF0U, 0x47B21BU, 0x47C959U, 0x47D1B2U, + 0x47E067U, 0x47F88CU, 0x4805E1U, 0x481D0AU, 0x482CDFU, 0x483434U, 0x484F76U, 0x48579DU, 0x486648U, 0x487EA3U, + 0x488827U, 0x4890CCU, 0x48A119U, 0x48B9F2U, 0x48C2B0U, 0x48DA5BU, 0x48EB8EU, 0x48F365U, 0x490686U, 0x491E6DU, + 0x492FB8U, 0x493753U, 0x494C11U, 0x4954FAU, 0x49652FU, 0x497DC4U, 0x498B40U, 0x4993ABU, 0x49A27EU, 0x49BA95U, + 0x49C1D7U, 0x49D93CU, 0x49E8E9U, 0x49F002U, 0x4A032CU, 0x4A1BC7U, 0x4A2A12U, 0x4A32F9U, 0x4A49BBU, 0x4A5150U, + 0x4A6085U, 0x4A786EU, 0x4A8EEAU, 0x4A9601U, 0x4AA7D4U, 0x4ABF3FU, 0x4AC47DU, 0x4ADC96U, 0x4AED43U, 0x4AF5A8U, + 0x4B004BU, 0x4B18A0U, 0x4B2975U, 0x4B319EU, 0x4B4ADCU, 0x4B5237U, 0x4B63E2U, 0x4B7B09U, 0x4B8D8DU, 0x4B9566U, + 0x4BA4B3U, 0x4BBC58U, 0x4BC71AU, 0x4BDFF1U, 0x4BEE24U, 0x4BF6CFU, 0x4C0878U, 0x4C1093U, 0x4C2146U, 0x4C39ADU, + 0x4C42EFU, 0x4C5A04U, 0x4C6BD1U, 0x4C733AU, 0x4C85BEU, 0x4C9D55U, 0x4CAC80U, 0x4CB46BU, 0x4CCF29U, 0x4CD7C2U, + 0x4CE617U, 0x4CFEFCU, 0x4D0B1FU, 0x4D13F4U, 0x4D2221U, 0x4D3ACAU, 0x4D4188U, 0x4D5963U, 0x4D68B6U, 0x4D705DU, + 0x4D86D9U, 0x4D9E32U, 0x4DAFE7U, 0x4DB70CU, 0x4DCC4EU, 0x4DD4A5U, 0x4DE570U, 0x4DFD9BU, 0x4E0EB5U, 0x4E165EU, + 0x4E278BU, 0x4E3F60U, 0x4E4422U, 0x4E5CC9U, 0x4E6D1CU, 0x4E75F7U, 0x4E8373U, 0x4E9B98U, 0x4EAA4DU, 0x4EB2A6U, + 0x4EC9E4U, 0x4ED10FU, 0x4EE0DAU, 0x4EF831U, 0x4F0DD2U, 0x4F1539U, 0x4F24ECU, 0x4F3C07U, 0x4F4745U, 0x4F5FAEU, + 0x4F6E7BU, 0x4F7690U, 0x4F8014U, 0x4F98FFU, 0x4FA92AU, 0x4FB1C1U, 0x4FCA83U, 0x4FD268U, 0x4FE3BDU, 0x4FFB56U, + 0x50018FU, 0x501964U, 0x5028B1U, 0x50305AU, 0x504B18U, 0x5053F3U, 0x506226U, 0x507ACDU, 0x508C49U, 0x5094A2U, + 0x50A577U, 0x50BD9CU, 0x50C6DEU, 0x50DE35U, 0x50EFE0U, 0x50F70BU, 0x5102E8U, 0x511A03U, 0x512BD6U, 0x51333DU, + 0x51487FU, 0x515094U, 0x516141U, 0x5179AAU, 0x518F2EU, 0x5197C5U, 0x51A610U, 0x51BEFBU, 0x51C5B9U, 0x51DD52U, + 0x51EC87U, 0x51F46CU, 0x520742U, 0x521FA9U, 0x522E7CU, 0x523697U, 0x524DD5U, 0x52553EU, 0x5264EBU, 0x527C00U, + 0x528A84U, 0x52926FU, 0x52A3BAU, 0x52BB51U, 0x52C013U, 0x52D8F8U, 0x52E92DU, 0x52F1C6U, 0x530425U, 0x531CCEU, + 0x532D1BU, 0x5335F0U, 0x534EB2U, 0x535659U, 0x53678CU, 0x537F67U, 0x5389E3U, 0x539108U, 0x53A0DDU, 0x53B836U, + 0x53C374U, 0x53DB9FU, 0x53EA4AU, 0x53F2A1U, 0x540C16U, 0x5414FDU, 0x542528U, 0x543DC3U, 0x544681U, 0x545E6AU, + 0x546FBFU, 0x547754U, 0x5481D0U, 0x54993BU, 0x54A8EEU, 0x54B005U, 0x54CB47U, 0x54D3ACU, 0x54E279U, 0x54FA92U, + 0x550F71U, 0x55179AU, 0x55264FU, 0x553EA4U, 0x5545E6U, 0x555D0DU, 0x556CD8U, 0x557433U, 0x5582B7U, 0x559A5CU, + 0x55AB89U, 0x55B362U, 0x55C820U, 0x55D0CBU, 0x55E11EU, 0x55F9F5U, 0x560ADBU, 0x561230U, 0x5623E5U, 0x563B0EU, + 0x56404CU, 0x5658A7U, 0x566972U, 0x567199U, 0x56871DU, 0x569FF6U, 0x56AE23U, 0x56B6C8U, 0x56CD8AU, 0x56D561U, + 0x56E4B4U, 0x56FC5FU, 0x5709BCU, 0x571157U, 0x572082U, 0x573869U, 0x57432BU, 0x575BC0U, 0x576A15U, 0x5772FEU, + 0x57847AU, 0x579C91U, 0x57AD44U, 0x57B5AFU, 0x57CEEDU, 0x57D606U, 0x57E7D3U, 0x57FF38U, 0x580255U, 0x581ABEU, + 0x582B6BU, 0x583380U, 0x5848C2U, 0x585029U, 0x5861FCU, 0x587917U, 0x588F93U, 0x589778U, 0x58A6ADU, 0x58BE46U, + 0x58C504U, 0x58DDEFU, 0x58EC3AU, 0x58F4D1U, 0x590132U, 0x5919D9U, 0x59280CU, 0x5930E7U, 0x594BA5U, 0x59534EU, + 0x59629BU, 0x597A70U, 0x598CF4U, 0x59941FU, 0x59A5CAU, 0x59BD21U, 0x59C663U, 0x59DE88U, 0x59EF5DU, 0x59F7B6U, + 0x5A0498U, 0x5A1C73U, 0x5A2DA6U, 0x5A354DU, 0x5A4E0FU, 0x5A56E4U, 0x5A6731U, 0x5A7FDAU, 0x5A895EU, 0x5A91B5U, + 0x5AA060U, 0x5AB88BU, 0x5AC3C9U, 0x5ADB22U, 0x5AEAF7U, 0x5AF21CU, 0x5B07FFU, 0x5B1F14U, 0x5B2EC1U, 0x5B362AU, + 0x5B4D68U, 0x5B5583U, 0x5B6456U, 0x5B7CBDU, 0x5B8A39U, 0x5B92D2U, 0x5BA307U, 0x5BBBECU, 0x5BC0AEU, 0x5BD845U, + 0x5BE990U, 0x5BF17BU, 0x5C0FCCU, 0x5C1727U, 0x5C26F2U, 0x5C3E19U, 0x5C455BU, 0x5C5DB0U, 0x5C6C65U, 0x5C748EU, + 0x5C820AU, 0x5C9AE1U, 0x5CAB34U, 0x5CB3DFU, 0x5CC89DU, 0x5CD076U, 0x5CE1A3U, 0x5CF948U, 0x5D0CABU, 0x5D1440U, + 0x5D2595U, 0x5D3D7EU, 0x5D463CU, 0x5D5ED7U, 0x5D6F02U, 0x5D77E9U, 0x5D816DU, 0x5D9986U, 0x5DA853U, 0x5DB0B8U, + 0x5DCBFAU, 0x5DD311U, 0x5DE2C4U, 0x5DFA2FU, 0x5E0901U, 0x5E11EAU, 0x5E203FU, 0x5E38D4U, 0x5E4396U, 0x5E5B7DU, + 0x5E6AA8U, 0x5E7243U, 0x5E84C7U, 0x5E9C2CU, 0x5EADF9U, 0x5EB512U, 0x5ECE50U, 0x5ED6BBU, 0x5EE76EU, 0x5EFF85U, + 0x5F0A66U, 0x5F128DU, 0x5F2358U, 0x5F3BB3U, 0x5F40F1U, 0x5F581AU, 0x5F69CFU, 0x5F7124U, 0x5F87A0U, 0x5F9F4BU, + 0x5FAE9EU, 0x5FB675U, 0x5FCD37U, 0x5FD5DCU, 0x5FE409U, 0x5FFCE2U, 0x600953U, 0x6011B8U, 0x60206DU, 0x603886U, + 0x6043C4U, 0x605B2FU, 0x606AFAU, 0x607211U, 0x608495U, 0x609C7EU, 0x60ADABU, 0x60B540U, 0x60CE02U, 0x60D6E9U, + 0x60E73CU, 0x60FFD7U, 0x610A34U, 0x6112DFU, 0x61230AU, 0x613BE1U, 0x6140A3U, 0x615848U, 0x61699DU, 0x617176U, + 0x6187F2U, 0x619F19U, 0x61AECCU, 0x61B627U, 0x61CD65U, 0x61D58EU, 0x61E45BU, 0x61FCB0U, 0x620F9EU, 0x621775U, + 0x6226A0U, 0x623E4BU, 0x624509U, 0x625DE2U, 0x626C37U, 0x6274DCU, 0x628258U, 0x629AB3U, 0x62AB66U, 0x62B38DU, + 0x62C8CFU, 0x62D024U, 0x62E1F1U, 0x62F91AU, 0x630CF9U, 0x631412U, 0x6325C7U, 0x633D2CU, 0x63466EU, 0x635E85U, + 0x636F50U, 0x6377BBU, 0x63813FU, 0x6399D4U, 0x63A801U, 0x63B0EAU, 0x63CBA8U, 0x63D343U, 0x63E296U, 0x63FA7DU, + 0x6404CAU, 0x641C21U, 0x642DF4U, 0x64351FU, 0x644E5DU, 0x6456B6U, 0x646763U, 0x647F88U, 0x64890CU, 0x6491E7U, + 0x64A032U, 0x64B8D9U, 0x64C39BU, 0x64DB70U, 0x64EAA5U, 0x64F24EU, 0x6507ADU, 0x651F46U, 0x652E93U, 0x653678U, + 0x654D3AU, 0x6555D1U, 0x656404U, 0x657CEFU, 0x658A6BU, 0x659280U, 0x65A355U, 0x65BBBEU, 0x65C0FCU, 0x65D817U, + 0x65E9C2U, 0x65F129U, 0x660207U, 0x661AECU, 0x662B39U, 0x6633D2U, 0x664890U, 0x66507BU, 0x6661AEU, 0x667945U, + 0x668FC1U, 0x66972AU, 0x66A6FFU, 0x66BE14U, 0x66C556U, 0x66DDBDU, 0x66EC68U, 0x66F483U, 0x670160U, 0x67198BU, + 0x67285EU, 0x6730B5U, 0x674BF7U, 0x67531CU, 0x6762C9U, 0x677A22U, 0x678CA6U, 0x67944DU, 0x67A598U, 0x67BD73U, + 0x67C631U, 0x67DEDAU, 0x67EF0FU, 0x67F7E4U, 0x680A89U, 0x681262U, 0x6823B7U, 0x683B5CU, 0x68401EU, 0x6858F5U, + 0x686920U, 0x6871CBU, 0x68874FU, 0x689FA4U, 0x68AE71U, 0x68B69AU, 0x68CDD8U, 0x68D533U, 0x68E4E6U, 0x68FC0DU, + 0x6909EEU, 0x691105U, 0x6920D0U, 0x69383BU, 0x694379U, 0x695B92U, 0x696A47U, 0x6972ACU, 0x698428U, 0x699CC3U, + 0x69AD16U, 0x69B5FDU, 0x69CEBFU, 0x69D654U, 0x69E781U, 0x69FF6AU, 0x6A0C44U, 0x6A14AFU, 0x6A257AU, 0x6A3D91U, + 0x6A46D3U, 0x6A5E38U, 0x6A6FEDU, 0x6A7706U, 0x6A8182U, 0x6A9969U, 0x6AA8BCU, 0x6AB057U, 0x6ACB15U, 0x6AD3FEU, + 0x6AE22BU, 0x6AFAC0U, 0x6B0F23U, 0x6B17C8U, 0x6B261DU, 0x6B3EF6U, 0x6B45B4U, 0x6B5D5FU, 0x6B6C8AU, 0x6B7461U, + 0x6B82E5U, 0x6B9A0EU, 0x6BABDBU, 0x6BB330U, 0x6BC872U, 0x6BD099U, 0x6BE14CU, 0x6BF9A7U, 0x6C0710U, 0x6C1FFBU, + 0x6C2E2EU, 0x6C36C5U, 0x6C4D87U, 0x6C556CU, 0x6C64B9U, 0x6C7C52U, 0x6C8AD6U, 0x6C923DU, 0x6CA3E8U, 0x6CBB03U, + 0x6CC041U, 0x6CD8AAU, 0x6CE97FU, 0x6CF194U, 0x6D0477U, 0x6D1C9CU, 0x6D2D49U, 0x6D35A2U, 0x6D4EE0U, 0x6D560BU, + 0x6D67DEU, 0x6D7F35U, 0x6D89B1U, 0x6D915AU, 0x6DA08FU, 0x6DB864U, 0x6DC326U, 0x6DDBCDU, 0x6DEA18U, 0x6DF2F3U, + 0x6E01DDU, 0x6E1936U, 0x6E28E3U, 0x6E3008U, 0x6E4B4AU, 0x6E53A1U, 0x6E6274U, 0x6E7A9FU, 0x6E8C1BU, 0x6E94F0U, + 0x6EA525U, 0x6EBDCEU, 0x6EC68CU, 0x6EDE67U, 0x6EEFB2U, 0x6EF759U, 0x6F02BAU, 0x6F1A51U, 0x6F2B84U, 0x6F336FU, + 0x6F482DU, 0x6F50C6U, 0x6F6113U, 0x6F79F8U, 0x6F8F7CU, 0x6F9797U, 0x6FA642U, 0x6FBEA9U, 0x6FC5EBU, 0x6FDD00U, + 0x6FECD5U, 0x6FF43EU, 0x700EE7U, 0x70160CU, 0x7027D9U, 0x703F32U, 0x704470U, 0x705C9BU, 0x706D4EU, 0x7075A5U, + 0x708321U, 0x709BCAU, 0x70AA1FU, 0x70B2F4U, 0x70C9B6U, 0x70D15DU, 0x70E088U, 0x70F863U, 0x710D80U, 0x71156BU, + 0x7124BEU, 0x713C55U, 0x714717U, 0x715FFCU, 0x716E29U, 0x7176C2U, 0x718046U, 0x7198ADU, 0x71A978U, 0x71B193U, + 0x71CAD1U, 0x71D23AU, 0x71E3EFU, 0x71FB04U, 0x72082AU, 0x7210C1U, 0x722114U, 0x7239FFU, 0x7242BDU, 0x725A56U, + 0x726B83U, 0x727368U, 0x7285ECU, 0x729D07U, 0x72ACD2U, 0x72B439U, 0x72CF7BU, 0x72D790U, 0x72E645U, 0x72FEAEU, + 0x730B4DU, 0x7313A6U, 0x732273U, 0x733A98U, 0x7341DAU, 0x735931U, 0x7368E4U, 0x73700FU, 0x73868BU, 0x739E60U, + 0x73AFB5U, 0x73B75EU, 0x73CC1CU, 0x73D4F7U, 0x73E522U, 0x73FDC9U, 0x74037EU, 0x741B95U, 0x742A40U, 0x7432ABU, + 0x7449E9U, 0x745102U, 0x7460D7U, 0x74783CU, 0x748EB8U, 0x749653U, 0x74A786U, 0x74BF6DU, 0x74C42FU, 0x74DCC4U, + 0x74ED11U, 0x74F5FAU, 0x750019U, 0x7518F2U, 0x752927U, 0x7531CCU, 0x754A8EU, 0x755265U, 0x7563B0U, 0x757B5BU, + 0x758DDFU, 0x759534U, 0x75A4E1U, 0x75BC0AU, 0x75C748U, 0x75DFA3U, 0x75EE76U, 0x75F69DU, 0x7605B3U, 0x761D58U, + 0x762C8DU, 0x763466U, 0x764F24U, 0x7657CFU, 0x76661AU, 0x767EF1U, 0x768875U, 0x76909EU, 0x76A14BU, 0x76B9A0U, + 0x76C2E2U, 0x76DA09U, 0x76EBDCU, 0x76F337U, 0x7706D4U, 0x771E3FU, 0x772FEAU, 0x773701U, 0x774C43U, 0x7754A8U, + 0x77657DU, 0x777D96U, 0x778B12U, 0x7793F9U, 0x77A22CU, 0x77BAC7U, 0x77C185U, 0x77D96EU, 0x77E8BBU, 0x77F050U, + 0x780D3DU, 0x7815D6U, 0x782403U, 0x783CE8U, 0x7847AAU, 0x785F41U, 0x786E94U, 0x78767FU, 0x7880FBU, 0x789810U, + 0x78A9C5U, 0x78B12EU, 0x78CA6CU, 0x78D287U, 0x78E352U, 0x78FBB9U, 0x790E5AU, 0x7916B1U, 0x792764U, 0x793F8FU, + 0x7944CDU, 0x795C26U, 0x796DF3U, 0x797518U, 0x79839CU, 0x799B77U, 0x79AAA2U, 0x79B249U, 0x79C90BU, 0x79D1E0U, + 0x79E035U, 0x79F8DEU, 0x7A0BF0U, 0x7A131BU, 0x7A22CEU, 0x7A3A25U, 0x7A4167U, 0x7A598CU, 0x7A6859U, 0x7A70B2U, + 0x7A8636U, 0x7A9EDDU, 0x7AAF08U, 0x7AB7E3U, 0x7ACCA1U, 0x7AD44AU, 0x7AE59FU, 0x7AFD74U, 0x7B0897U, 0x7B107CU, + 0x7B21A9U, 0x7B3942U, 0x7B4200U, 0x7B5AEBU, 0x7B6B3EU, 0x7B73D5U, 0x7B8551U, 0x7B9DBAU, 0x7BAC6FU, 0x7BB484U, + 0x7BCFC6U, 0x7BD72DU, 0x7BE6F8U, 0x7BFE13U, 0x7C00A4U, 0x7C184FU, 0x7C299AU, 0x7C3171U, 0x7C4A33U, 0x7C52D8U, + 0x7C630DU, 0x7C7BE6U, 0x7C8D62U, 0x7C9589U, 0x7CA45CU, 0x7CBCB7U, 0x7CC7F5U, 0x7CDF1EU, 0x7CEECBU, 0x7CF620U, + 0x7D03C3U, 0x7D1B28U, 0x7D2AFDU, 0x7D3216U, 0x7D4954U, 0x7D51BFU, 0x7D606AU, 0x7D7881U, 0x7D8E05U, 0x7D96EEU, + 0x7DA73BU, 0x7DBFD0U, 0x7DC492U, 0x7DDC79U, 0x7DEDACU, 0x7DF547U, 0x7E0669U, 0x7E1E82U, 0x7E2F57U, 0x7E37BCU, + 0x7E4CFEU, 0x7E5415U, 0x7E65C0U, 0x7E7D2BU, 0x7E8BAFU, 0x7E9344U, 0x7EA291U, 0x7EBA7AU, 0x7EC138U, 0x7ED9D3U, + 0x7EE806U, 0x7EF0EDU, 0x7F050EU, 0x7F1DE5U, 0x7F2C30U, 0x7F34DBU, 0x7F4F99U, 0x7F5772U, 0x7F66A7U, 0x7F7E4CU, + 0x7F88C8U, 0x7F9023U, 0x7FA1F6U, 0x7FB91DU, 0x7FC25FU, 0x7FDAB4U, 0x7FEB61U, 0x7FF38AU, 0x800C75U, 0x80149EU, + 0x80254BU, 0x803DA0U, 0x8046E2U, 0x805E09U, 0x806FDCU, 0x807737U, 0x8081B3U, 0x809958U, 0x80A88DU, 0x80B066U, + 0x80CB24U, 0x80D3CFU, 0x80E21AU, 0x80FAF1U, 0x810F12U, 0x8117F9U, 0x81262CU, 0x813EC7U, 0x814585U, 0x815D6EU, + 0x816CBBU, 0x817450U, 0x8182D4U, 0x819A3FU, 0x81ABEAU, 0x81B301U, 0x81C843U, 0x81D0A8U, 0x81E17DU, 0x81F996U, + 0x820AB8U, 0x821253U, 0x822386U, 0x823B6DU, 0x82402FU, 0x8258C4U, 0x826911U, 0x8271FAU, 0x82877EU, 0x829F95U, + 0x82AE40U, 0x82B6ABU, 0x82CDE9U, 0x82D502U, 0x82E4D7U, 0x82FC3CU, 0x8309DFU, 0x831134U, 0x8320E1U, 0x83380AU, + 0x834348U, 0x835BA3U, 0x836A76U, 0x83729DU, 0x838419U, 0x839CF2U, 0x83AD27U, 0x83B5CCU, 0x83CE8EU, 0x83D665U, + 0x83E7B0U, 0x83FF5BU, 0x8401ECU, 0x841907U, 0x8428D2U, 0x843039U, 0x844B7BU, 0x845390U, 0x846245U, 0x847AAEU, + 0x848C2AU, 0x8494C1U, 0x84A514U, 0x84BDFFU, 0x84C6BDU, 0x84DE56U, 0x84EF83U, 0x84F768U, 0x85028BU, 0x851A60U, + 0x852BB5U, 0x85335EU, 0x85481CU, 0x8550F7U, 0x856122U, 0x8579C9U, 0x858F4DU, 0x8597A6U, 0x85A673U, 0x85BE98U, + 0x85C5DAU, 0x85DD31U, 0x85ECE4U, 0x85F40FU, 0x860721U, 0x861FCAU, 0x862E1FU, 0x8636F4U, 0x864DB6U, 0x86555DU, + 0x866488U, 0x867C63U, 0x868AE7U, 0x86920CU, 0x86A3D9U, 0x86BB32U, 0x86C070U, 0x86D89BU, 0x86E94EU, 0x86F1A5U, + 0x870446U, 0x871CADU, 0x872D78U, 0x873593U, 0x874ED1U, 0x87563AU, 0x8767EFU, 0x877F04U, 0x878980U, 0x87916BU, + 0x87A0BEU, 0x87B855U, 0x87C317U, 0x87DBFCU, 0x87EA29U, 0x87F2C2U, 0x880FAFU, 0x881744U, 0x882691U, 0x883E7AU, + 0x884538U, 0x885DD3U, 0x886C06U, 0x8874EDU, 0x888269U, 0x889A82U, 0x88AB57U, 0x88B3BCU, 0x88C8FEU, 0x88D015U, + 0x88E1C0U, 0x88F92BU, 0x890CC8U, 0x891423U, 0x8925F6U, 0x893D1DU, 0x89465FU, 0x895EB4U, 0x896F61U, 0x89778AU, + 0x89810EU, 0x8999E5U, 0x89A830U, 0x89B0DBU, 0x89CB99U, 0x89D372U, 0x89E2A7U, 0x89FA4CU, 0x8A0962U, 0x8A1189U, + 0x8A205CU, 0x8A38B7U, 0x8A43F5U, 0x8A5B1EU, 0x8A6ACBU, 0x8A7220U, 0x8A84A4U, 0x8A9C4FU, 0x8AAD9AU, 0x8AB571U, + 0x8ACE33U, 0x8AD6D8U, 0x8AE70DU, 0x8AFFE6U, 0x8B0A05U, 0x8B12EEU, 0x8B233BU, 0x8B3BD0U, 0x8B4092U, 0x8B5879U, + 0x8B69ACU, 0x8B7147U, 0x8B87C3U, 0x8B9F28U, 0x8BAEFDU, 0x8BB616U, 0x8BCD54U, 0x8BD5BFU, 0x8BE46AU, 0x8BFC81U, + 0x8C0236U, 0x8C1ADDU, 0x8C2B08U, 0x8C33E3U, 0x8C48A1U, 0x8C504AU, 0x8C619FU, 0x8C7974U, 0x8C8FF0U, 0x8C971BU, + 0x8CA6CEU, 0x8CBE25U, 0x8CC567U, 0x8CDD8CU, 0x8CEC59U, 0x8CF4B2U, 0x8D0151U, 0x8D19BAU, 0x8D286FU, 0x8D3084U, + 0x8D4BC6U, 0x8D532DU, 0x8D62F8U, 0x8D7A13U, 0x8D8C97U, 0x8D947CU, 0x8DA5A9U, 0x8DBD42U, 0x8DC600U, 0x8DDEEBU, + 0x8DEF3EU, 0x8DF7D5U, 0x8E04FBU, 0x8E1C10U, 0x8E2DC5U, 0x8E352EU, 0x8E4E6CU, 0x8E5687U, 0x8E6752U, 0x8E7FB9U, + 0x8E893DU, 0x8E91D6U, 0x8EA003U, 0x8EB8E8U, 0x8EC3AAU, 0x8EDB41U, 0x8EEA94U, 0x8EF27FU, 0x8F079CU, 0x8F1F77U, + 0x8F2EA2U, 0x8F3649U, 0x8F4D0BU, 0x8F55E0U, 0x8F6435U, 0x8F7CDEU, 0x8F8A5AU, 0x8F92B1U, 0x8FA364U, 0x8FBB8FU, + 0x8FC0CDU, 0x8FD826U, 0x8FE9F3U, 0x8FF118U, 0x900BC1U, 0x90132AU, 0x9022FFU, 0x903A14U, 0x904156U, 0x9059BDU, + 0x906868U, 0x907083U, 0x908607U, 0x909EECU, 0x90AF39U, 0x90B7D2U, 0x90CC90U, 0x90D47BU, 0x90E5AEU, 0x90FD45U, + 0x9108A6U, 0x91104DU, 0x912198U, 0x913973U, 0x914231U, 0x915ADAU, 0x916B0FU, 0x9173E4U, 0x918560U, 0x919D8BU, + 0x91AC5EU, 0x91B4B5U, 0x91CFF7U, 0x91D71CU, 0x91E6C9U, 0x91FE22U, 0x920D0CU, 0x9215E7U, 0x922432U, 0x923CD9U, + 0x92479BU, 0x925F70U, 0x926EA5U, 0x92764EU, 0x9280CAU, 0x929821U, 0x92A9F4U, 0x92B11FU, 0x92CA5DU, 0x92D2B6U, + 0x92E363U, 0x92FB88U, 0x930E6BU, 0x931680U, 0x932755U, 0x933FBEU, 0x9344FCU, 0x935C17U, 0x936DC2U, 0x937529U, + 0x9383ADU, 0x939B46U, 0x93AA93U, 0x93B278U, 0x93C93AU, 0x93D1D1U, 0x93E004U, 0x93F8EFU, 0x940658U, 0x941EB3U, + 0x942F66U, 0x94378DU, 0x944CCFU, 0x945424U, 0x9465F1U, 0x947D1AU, 0x948B9EU, 0x949375U, 0x94A2A0U, 0x94BA4BU, + 0x94C109U, 0x94D9E2U, 0x94E837U, 0x94F0DCU, 0x95053FU, 0x951DD4U, 0x952C01U, 0x9534EAU, 0x954FA8U, 0x955743U, + 0x956696U, 0x957E7DU, 0x9588F9U, 0x959012U, 0x95A1C7U, 0x95B92CU, 0x95C26EU, 0x95DA85U, 0x95EB50U, 0x95F3BBU, + 0x960095U, 0x96187EU, 0x9629ABU, 0x963140U, 0x964A02U, 0x9652E9U, 0x96633CU, 0x967BD7U, 0x968D53U, 0x9695B8U, + 0x96A46DU, 0x96BC86U, 0x96C7C4U, 0x96DF2FU, 0x96EEFAU, 0x96F611U, 0x9703F2U, 0x971B19U, 0x972ACCU, 0x973227U, + 0x974965U, 0x97518EU, 0x97605BU, 0x9778B0U, 0x978E34U, 0x9796DFU, 0x97A70AU, 0x97BFE1U, 0x97C4A3U, 0x97DC48U, + 0x97ED9DU, 0x97F576U, 0x98081BU, 0x9810F0U, 0x982125U, 0x9839CEU, 0x98428CU, 0x985A67U, 0x986BB2U, 0x987359U, + 0x9885DDU, 0x989D36U, 0x98ACE3U, 0x98B408U, 0x98CF4AU, 0x98D7A1U, 0x98E674U, 0x98FE9FU, 0x990B7CU, 0x991397U, + 0x992242U, 0x993AA9U, 0x9941EBU, 0x995900U, 0x9968D5U, 0x99703EU, 0x9986BAU, 0x999E51U, 0x99AF84U, 0x99B76FU, + 0x99CC2DU, 0x99D4C6U, 0x99E513U, 0x99FDF8U, 0x9A0ED6U, 0x9A163DU, 0x9A27E8U, 0x9A3F03U, 0x9A4441U, 0x9A5CAAU, + 0x9A6D7FU, 0x9A7594U, 0x9A8310U, 0x9A9BFBU, 0x9AAA2EU, 0x9AB2C5U, 0x9AC987U, 0x9AD16CU, 0x9AE0B9U, 0x9AF852U, + 0x9B0DB1U, 0x9B155AU, 0x9B248FU, 0x9B3C64U, 0x9B4726U, 0x9B5FCDU, 0x9B6E18U, 0x9B76F3U, 0x9B8077U, 0x9B989CU, + 0x9BA949U, 0x9BB1A2U, 0x9BCAE0U, 0x9BD20BU, 0x9BE3DEU, 0x9BFB35U, 0x9C0582U, 0x9C1D69U, 0x9C2CBCU, 0x9C3457U, + 0x9C4F15U, 0x9C57FEU, 0x9C662BU, 0x9C7EC0U, 0x9C8844U, 0x9C90AFU, 0x9CA17AU, 0x9CB991U, 0x9CC2D3U, 0x9CDA38U, + 0x9CEBEDU, 0x9CF306U, 0x9D06E5U, 0x9D1E0EU, 0x9D2FDBU, 0x9D3730U, 0x9D4C72U, 0x9D5499U, 0x9D654CU, 0x9D7DA7U, + 0x9D8B23U, 0x9D93C8U, 0x9DA21DU, 0x9DBAF6U, 0x9DC1B4U, 0x9DD95FU, 0x9DE88AU, 0x9DF061U, 0x9E034FU, 0x9E1BA4U, + 0x9E2A71U, 0x9E329AU, 0x9E49D8U, 0x9E5133U, 0x9E60E6U, 0x9E780DU, 0x9E8E89U, 0x9E9662U, 0x9EA7B7U, 0x9EBF5CU, + 0x9EC41EU, 0x9EDCF5U, 0x9EED20U, 0x9EF5CBU, 0x9F0028U, 0x9F18C3U, 0x9F2916U, 0x9F31FDU, 0x9F4ABFU, 0x9F5254U, + 0x9F6381U, 0x9F7B6AU, 0x9F8DEEU, 0x9F9505U, 0x9FA4D0U, 0x9FBC3BU, 0x9FC779U, 0x9FDF92U, 0x9FEE47U, 0x9FF6ACU, + 0xA0031DU, 0xA01BF6U, 0xA02A23U, 0xA032C8U, 0xA0498AU, 0xA05161U, 0xA060B4U, 0xA0785FU, 0xA08EDBU, 0xA09630U, + 0xA0A7E5U, 0xA0BF0EU, 0xA0C44CU, 0xA0DCA7U, 0xA0ED72U, 0xA0F599U, 0xA1007AU, 0xA11891U, 0xA12944U, 0xA131AFU, + 0xA14AEDU, 0xA15206U, 0xA163D3U, 0xA17B38U, 0xA18DBCU, 0xA19557U, 0xA1A482U, 0xA1BC69U, 0xA1C72BU, 0xA1DFC0U, + 0xA1EE15U, 0xA1F6FEU, 0xA205D0U, 0xA21D3BU, 0xA22CEEU, 0xA23405U, 0xA24F47U, 0xA257ACU, 0xA26679U, 0xA27E92U, + 0xA28816U, 0xA290FDU, 0xA2A128U, 0xA2B9C3U, 0xA2C281U, 0xA2DA6AU, 0xA2EBBFU, 0xA2F354U, 0xA306B7U, 0xA31E5CU, + 0xA32F89U, 0xA33762U, 0xA34C20U, 0xA354CBU, 0xA3651EU, 0xA37DF5U, 0xA38B71U, 0xA3939AU, 0xA3A24FU, 0xA3BAA4U, + 0xA3C1E6U, 0xA3D90DU, 0xA3E8D8U, 0xA3F033U, 0xA40E84U, 0xA4166FU, 0xA427BAU, 0xA43F51U, 0xA44413U, 0xA45CF8U, + 0xA46D2DU, 0xA475C6U, 0xA48342U, 0xA49BA9U, 0xA4AA7CU, 0xA4B297U, 0xA4C9D5U, 0xA4D13EU, 0xA4E0EBU, 0xA4F800U, + 0xA50DE3U, 0xA51508U, 0xA524DDU, 0xA53C36U, 0xA54774U, 0xA55F9FU, 0xA56E4AU, 0xA576A1U, 0xA58025U, 0xA598CEU, + 0xA5A91BU, 0xA5B1F0U, 0xA5CAB2U, 0xA5D259U, 0xA5E38CU, 0xA5FB67U, 0xA60849U, 0xA610A2U, 0xA62177U, 0xA6399CU, + 0xA642DEU, 0xA65A35U, 0xA66BE0U, 0xA6730BU, 0xA6858FU, 0xA69D64U, 0xA6ACB1U, 0xA6B45AU, 0xA6CF18U, 0xA6D7F3U, + 0xA6E626U, 0xA6FECDU, 0xA70B2EU, 0xA713C5U, 0xA72210U, 0xA73AFBU, 0xA741B9U, 0xA75952U, 0xA76887U, 0xA7706CU, + 0xA786E8U, 0xA79E03U, 0xA7AFD6U, 0xA7B73DU, 0xA7CC7FU, 0xA7D494U, 0xA7E541U, 0xA7FDAAU, 0xA800C7U, 0xA8182CU, + 0xA829F9U, 0xA83112U, 0xA84A50U, 0xA852BBU, 0xA8636EU, 0xA87B85U, 0xA88D01U, 0xA895EAU, 0xA8A43FU, 0xA8BCD4U, + 0xA8C796U, 0xA8DF7DU, 0xA8EEA8U, 0xA8F643U, 0xA903A0U, 0xA91B4BU, 0xA92A9EU, 0xA93275U, 0xA94937U, 0xA951DCU, + 0xA96009U, 0xA978E2U, 0xA98E66U, 0xA9968DU, 0xA9A758U, 0xA9BFB3U, 0xA9C4F1U, 0xA9DC1AU, 0xA9EDCFU, 0xA9F524U, + 0xAA060AU, 0xAA1EE1U, 0xAA2F34U, 0xAA37DFU, 0xAA4C9DU, 0xAA5476U, 0xAA65A3U, 0xAA7D48U, 0xAA8BCCU, 0xAA9327U, + 0xAAA2F2U, 0xAABA19U, 0xAAC15BU, 0xAAD9B0U, 0xAAE865U, 0xAAF08EU, 0xAB056DU, 0xAB1D86U, 0xAB2C53U, 0xAB34B8U, + 0xAB4FFAU, 0xAB5711U, 0xAB66C4U, 0xAB7E2FU, 0xAB88ABU, 0xAB9040U, 0xABA195U, 0xABB97EU, 0xABC23CU, 0xABDAD7U, + 0xABEB02U, 0xABF3E9U, 0xAC0D5EU, 0xAC15B5U, 0xAC2460U, 0xAC3C8BU, 0xAC47C9U, 0xAC5F22U, 0xAC6EF7U, 0xAC761CU, + 0xAC8098U, 0xAC9873U, 0xACA9A6U, 0xACB14DU, 0xACCA0FU, 0xACD2E4U, 0xACE331U, 0xACFBDAU, 0xAD0E39U, 0xAD16D2U, + 0xAD2707U, 0xAD3FECU, 0xAD44AEU, 0xAD5C45U, 0xAD6D90U, 0xAD757BU, 0xAD83FFU, 0xAD9B14U, 0xADAAC1U, 0xADB22AU, + 0xADC968U, 0xADD183U, 0xADE056U, 0xADF8BDU, 0xAE0B93U, 0xAE1378U, 0xAE22ADU, 0xAE3A46U, 0xAE4104U, 0xAE59EFU, + 0xAE683AU, 0xAE70D1U, 0xAE8655U, 0xAE9EBEU, 0xAEAF6BU, 0xAEB780U, 0xAECCC2U, 0xAED429U, 0xAEE5FCU, 0xAEFD17U, + 0xAF08F4U, 0xAF101FU, 0xAF21CAU, 0xAF3921U, 0xAF4263U, 0xAF5A88U, 0xAF6B5DU, 0xAF73B6U, 0xAF8532U, 0xAF9DD9U, + 0xAFAC0CU, 0xAFB4E7U, 0xAFCFA5U, 0xAFD74EU, 0xAFE69BU, 0xAFFE70U, 0xB004A9U, 0xB01C42U, 0xB02D97U, 0xB0357CU, + 0xB04E3EU, 0xB056D5U, 0xB06700U, 0xB07FEBU, 0xB0896FU, 0xB09184U, 0xB0A051U, 0xB0B8BAU, 0xB0C3F8U, 0xB0DB13U, + 0xB0EAC6U, 0xB0F22DU, 0xB107CEU, 0xB11F25U, 0xB12EF0U, 0xB1361BU, 0xB14D59U, 0xB155B2U, 0xB16467U, 0xB17C8CU, + 0xB18A08U, 0xB192E3U, 0xB1A336U, 0xB1BBDDU, 0xB1C09FU, 0xB1D874U, 0xB1E9A1U, 0xB1F14AU, 0xB20264U, 0xB21A8FU, + 0xB22B5AU, 0xB233B1U, 0xB248F3U, 0xB25018U, 0xB261CDU, 0xB27926U, 0xB28FA2U, 0xB29749U, 0xB2A69CU, 0xB2BE77U, + 0xB2C535U, 0xB2DDDEU, 0xB2EC0BU, 0xB2F4E0U, 0xB30103U, 0xB319E8U, 0xB3283DU, 0xB330D6U, 0xB34B94U, 0xB3537FU, + 0xB362AAU, 0xB37A41U, 0xB38CC5U, 0xB3942EU, 0xB3A5FBU, 0xB3BD10U, 0xB3C652U, 0xB3DEB9U, 0xB3EF6CU, 0xB3F787U, + 0xB40930U, 0xB411DBU, 0xB4200EU, 0xB438E5U, 0xB443A7U, 0xB45B4CU, 0xB46A99U, 0xB47272U, 0xB484F6U, 0xB49C1DU, + 0xB4ADC8U, 0xB4B523U, 0xB4CE61U, 0xB4D68AU, 0xB4E75FU, 0xB4FFB4U, 0xB50A57U, 0xB512BCU, 0xB52369U, 0xB53B82U, + 0xB540C0U, 0xB5582BU, 0xB569FEU, 0xB57115U, 0xB58791U, 0xB59F7AU, 0xB5AEAFU, 0xB5B644U, 0xB5CD06U, 0xB5D5EDU, + 0xB5E438U, 0xB5FCD3U, 0xB60FFDU, 0xB61716U, 0xB626C3U, 0xB63E28U, 0xB6456AU, 0xB65D81U, 0xB66C54U, 0xB674BFU, + 0xB6823BU, 0xB69AD0U, 0xB6AB05U, 0xB6B3EEU, 0xB6C8ACU, 0xB6D047U, 0xB6E192U, 0xB6F979U, 0xB70C9AU, 0xB71471U, + 0xB725A4U, 0xB73D4FU, 0xB7460DU, 0xB75EE6U, 0xB76F33U, 0xB777D8U, 0xB7815CU, 0xB799B7U, 0xB7A862U, 0xB7B089U, + 0xB7CBCBU, 0xB7D320U, 0xB7E2F5U, 0xB7FA1EU, 0xB80773U, 0xB81F98U, 0xB82E4DU, 0xB836A6U, 0xB84DE4U, 0xB8550FU, + 0xB864DAU, 0xB87C31U, 0xB88AB5U, 0xB8925EU, 0xB8A38BU, 0xB8BB60U, 0xB8C022U, 0xB8D8C9U, 0xB8E91CU, 0xB8F1F7U, + 0xB90414U, 0xB91CFFU, 0xB92D2AU, 0xB935C1U, 0xB94E83U, 0xB95668U, 0xB967BDU, 0xB97F56U, 0xB989D2U, 0xB99139U, + 0xB9A0ECU, 0xB9B807U, 0xB9C345U, 0xB9DBAEU, 0xB9EA7BU, 0xB9F290U, 0xBA01BEU, 0xBA1955U, 0xBA2880U, 0xBA306BU, + 0xBA4B29U, 0xBA53C2U, 0xBA6217U, 0xBA7AFCU, 0xBA8C78U, 0xBA9493U, 0xBAA546U, 0xBABDADU, 0xBAC6EFU, 0xBADE04U, + 0xBAEFD1U, 0xBAF73AU, 0xBB02D9U, 0xBB1A32U, 0xBB2BE7U, 0xBB330CU, 0xBB484EU, 0xBB50A5U, 0xBB6170U, 0xBB799BU, + 0xBB8F1FU, 0xBB97F4U, 0xBBA621U, 0xBBBECAU, 0xBBC588U, 0xBBDD63U, 0xBBECB6U, 0xBBF45DU, 0xBC0AEAU, 0xBC1201U, + 0xBC23D4U, 0xBC3B3FU, 0xBC407DU, 0xBC5896U, 0xBC6943U, 0xBC71A8U, 0xBC872CU, 0xBC9FC7U, 0xBCAE12U, 0xBCB6F9U, + 0xBCCDBBU, 0xBCD550U, 0xBCE485U, 0xBCFC6EU, 0xBD098DU, 0xBD1166U, 0xBD20B3U, 0xBD3858U, 0xBD431AU, 0xBD5BF1U, + 0xBD6A24U, 0xBD72CFU, 0xBD844BU, 0xBD9CA0U, 0xBDAD75U, 0xBDB59EU, 0xBDCEDCU, 0xBDD637U, 0xBDE7E2U, 0xBDFF09U, + 0xBE0C27U, 0xBE14CCU, 0xBE2519U, 0xBE3DF2U, 0xBE46B0U, 0xBE5E5BU, 0xBE6F8EU, 0xBE7765U, 0xBE81E1U, 0xBE990AU, + 0xBEA8DFU, 0xBEB034U, 0xBECB76U, 0xBED39DU, 0xBEE248U, 0xBEFAA3U, 0xBF0F40U, 0xBF17ABU, 0xBF267EU, 0xBF3E95U, + 0xBF45D7U, 0xBF5D3CU, 0xBF6CE9U, 0xBF7402U, 0xBF8286U, 0xBF9A6DU, 0xBFABB8U, 0xBFB353U, 0xBFC811U, 0xBFD0FAU, + 0xBFE12FU, 0xBFF9C4U, 0xC00A4EU, 0xC012A5U, 0xC02370U, 0xC03B9BU, 0xC040D9U, 0xC05832U, 0xC069E7U, 0xC0710CU, + 0xC08788U, 0xC09F63U, 0xC0AEB6U, 0xC0B65DU, 0xC0CD1FU, 0xC0D5F4U, 0xC0E421U, 0xC0FCCAU, 0xC10929U, 0xC111C2U, + 0xC12017U, 0xC138FCU, 0xC143BEU, 0xC15B55U, 0xC16A80U, 0xC1726BU, 0xC184EFU, 0xC19C04U, 0xC1ADD1U, 0xC1B53AU, + 0xC1CE78U, 0xC1D693U, 0xC1E746U, 0xC1FFADU, 0xC20C83U, 0xC21468U, 0xC225BDU, 0xC23D56U, 0xC24614U, 0xC25EFFU, + 0xC26F2AU, 0xC277C1U, 0xC28145U, 0xC299AEU, 0xC2A87BU, 0xC2B090U, 0xC2CBD2U, 0xC2D339U, 0xC2E2ECU, 0xC2FA07U, + 0xC30FE4U, 0xC3170FU, 0xC326DAU, 0xC33E31U, 0xC34573U, 0xC35D98U, 0xC36C4DU, 0xC374A6U, 0xC38222U, 0xC39AC9U, + 0xC3AB1CU, 0xC3B3F7U, 0xC3C8B5U, 0xC3D05EU, 0xC3E18BU, 0xC3F960U, 0xC407D7U, 0xC41F3CU, 0xC42EE9U, 0xC43602U, + 0xC44D40U, 0xC455ABU, 0xC4647EU, 0xC47C95U, 0xC48A11U, 0xC492FAU, 0xC4A32FU, 0xC4BBC4U, 0xC4C086U, 0xC4D86DU, + 0xC4E9B8U, 0xC4F153U, 0xC504B0U, 0xC51C5BU, 0xC52D8EU, 0xC53565U, 0xC54E27U, 0xC556CCU, 0xC56719U, 0xC57FF2U, + 0xC58976U, 0xC5919DU, 0xC5A048U, 0xC5B8A3U, 0xC5C3E1U, 0xC5DB0AU, 0xC5EADFU, 0xC5F234U, 0xC6011AU, 0xC619F1U, + 0xC62824U, 0xC630CFU, 0xC64B8DU, 0xC65366U, 0xC662B3U, 0xC67A58U, 0xC68CDCU, 0xC69437U, 0xC6A5E2U, 0xC6BD09U, + 0xC6C64BU, 0xC6DEA0U, 0xC6EF75U, 0xC6F79EU, 0xC7027DU, 0xC71A96U, 0xC72B43U, 0xC733A8U, 0xC748EAU, 0xC75001U, + 0xC761D4U, 0xC7793FU, 0xC78FBBU, 0xC79750U, 0xC7A685U, 0xC7BE6EU, 0xC7C52CU, 0xC7DDC7U, 0xC7EC12U, 0xC7F4F9U, + 0xC80994U, 0xC8117FU, 0xC820AAU, 0xC83841U, 0xC84303U, 0xC85BE8U, 0xC86A3DU, 0xC872D6U, 0xC88452U, 0xC89CB9U, + 0xC8AD6CU, 0xC8B587U, 0xC8CEC5U, 0xC8D62EU, 0xC8E7FBU, 0xC8FF10U, 0xC90AF3U, 0xC91218U, 0xC923CDU, 0xC93B26U, + 0xC94064U, 0xC9588FU, 0xC9695AU, 0xC971B1U, 0xC98735U, 0xC99FDEU, 0xC9AE0BU, 0xC9B6E0U, 0xC9CDA2U, 0xC9D549U, + 0xC9E49CU, 0xC9FC77U, 0xCA0F59U, 0xCA17B2U, 0xCA2667U, 0xCA3E8CU, 0xCA45CEU, 0xCA5D25U, 0xCA6CF0U, 0xCA741BU, + 0xCA829FU, 0xCA9A74U, 0xCAABA1U, 0xCAB34AU, 0xCAC808U, 0xCAD0E3U, 0xCAE136U, 0xCAF9DDU, 0xCB0C3EU, 0xCB14D5U, + 0xCB2500U, 0xCB3DEBU, 0xCB46A9U, 0xCB5E42U, 0xCB6F97U, 0xCB777CU, 0xCB81F8U, 0xCB9913U, 0xCBA8C6U, 0xCBB02DU, + 0xCBCB6FU, 0xCBD384U, 0xCBE251U, 0xCBFABAU, 0xCC040DU, 0xCC1CE6U, 0xCC2D33U, 0xCC35D8U, 0xCC4E9AU, 0xCC5671U, + 0xCC67A4U, 0xCC7F4FU, 0xCC89CBU, 0xCC9120U, 0xCCA0F5U, 0xCCB81EU, 0xCCC35CU, 0xCCDBB7U, 0xCCEA62U, 0xCCF289U, + 0xCD076AU, 0xCD1F81U, 0xCD2E54U, 0xCD36BFU, 0xCD4DFDU, 0xCD5516U, 0xCD64C3U, 0xCD7C28U, 0xCD8AACU, 0xCD9247U, + 0xCDA392U, 0xCDBB79U, 0xCDC03BU, 0xCDD8D0U, 0xCDE905U, 0xCDF1EEU, 0xCE02C0U, 0xCE1A2BU, 0xCE2BFEU, 0xCE3315U, + 0xCE4857U, 0xCE50BCU, 0xCE6169U, 0xCE7982U, 0xCE8F06U, 0xCE97EDU, 0xCEA638U, 0xCEBED3U, 0xCEC591U, 0xCEDD7AU, + 0xCEECAFU, 0xCEF444U, 0xCF01A7U, 0xCF194CU, 0xCF2899U, 0xCF3072U, 0xCF4B30U, 0xCF53DBU, 0xCF620EU, 0xCF7AE5U, + 0xCF8C61U, 0xCF948AU, 0xCFA55FU, 0xCFBDB4U, 0xCFC6F6U, 0xCFDE1DU, 0xCFEFC8U, 0xCFF723U, 0xD00DFAU, 0xD01511U, + 0xD024C4U, 0xD03C2FU, 0xD0476DU, 0xD05F86U, 0xD06E53U, 0xD076B8U, 0xD0803CU, 0xD098D7U, 0xD0A902U, 0xD0B1E9U, + 0xD0CAABU, 0xD0D240U, 0xD0E395U, 0xD0FB7EU, 0xD10E9DU, 0xD11676U, 0xD127A3U, 0xD13F48U, 0xD1440AU, 0xD15CE1U, + 0xD16D34U, 0xD175DFU, 0xD1835BU, 0xD19BB0U, 0xD1AA65U, 0xD1B28EU, 0xD1C9CCU, 0xD1D127U, 0xD1E0F2U, 0xD1F819U, + 0xD20B37U, 0xD213DCU, 0xD22209U, 0xD23AE2U, 0xD241A0U, 0xD2594BU, 0xD2689EU, 0xD27075U, 0xD286F1U, 0xD29E1AU, + 0xD2AFCFU, 0xD2B724U, 0xD2CC66U, 0xD2D48DU, 0xD2E558U, 0xD2FDB3U, 0xD30850U, 0xD310BBU, 0xD3216EU, 0xD33985U, + 0xD342C7U, 0xD35A2CU, 0xD36BF9U, 0xD37312U, 0xD38596U, 0xD39D7DU, 0xD3ACA8U, 0xD3B443U, 0xD3CF01U, 0xD3D7EAU, + 0xD3E63FU, 0xD3FED4U, 0xD40063U, 0xD41888U, 0xD4295DU, 0xD431B6U, 0xD44AF4U, 0xD4521FU, 0xD463CAU, 0xD47B21U, + 0xD48DA5U, 0xD4954EU, 0xD4A49BU, 0xD4BC70U, 0xD4C732U, 0xD4DFD9U, 0xD4EE0CU, 0xD4F6E7U, 0xD50304U, 0xD51BEFU, + 0xD52A3AU, 0xD532D1U, 0xD54993U, 0xD55178U, 0xD560ADU, 0xD57846U, 0xD58EC2U, 0xD59629U, 0xD5A7FCU, 0xD5BF17U, + 0xD5C455U, 0xD5DCBEU, 0xD5ED6BU, 0xD5F580U, 0xD606AEU, 0xD61E45U, 0xD62F90U, 0xD6377BU, 0xD64C39U, 0xD654D2U, + 0xD66507U, 0xD67DECU, 0xD68B68U, 0xD69383U, 0xD6A256U, 0xD6BABDU, 0xD6C1FFU, 0xD6D914U, 0xD6E8C1U, 0xD6F02AU, + 0xD705C9U, 0xD71D22U, 0xD72CF7U, 0xD7341CU, 0xD74F5EU, 0xD757B5U, 0xD76660U, 0xD77E8BU, 0xD7880FU, 0xD790E4U, + 0xD7A131U, 0xD7B9DAU, 0xD7C298U, 0xD7DA73U, 0xD7EBA6U, 0xD7F34DU, 0xD80E20U, 0xD816CBU, 0xD8271EU, 0xD83FF5U, + 0xD844B7U, 0xD85C5CU, 0xD86D89U, 0xD87562U, 0xD883E6U, 0xD89B0DU, 0xD8AAD8U, 0xD8B233U, 0xD8C971U, 0xD8D19AU, + 0xD8E04FU, 0xD8F8A4U, 0xD90D47U, 0xD915ACU, 0xD92479U, 0xD93C92U, 0xD947D0U, 0xD95F3BU, 0xD96EEEU, 0xD97605U, + 0xD98081U, 0xD9986AU, 0xD9A9BFU, 0xD9B154U, 0xD9CA16U, 0xD9D2FDU, 0xD9E328U, 0xD9FBC3U, 0xDA08EDU, 0xDA1006U, + 0xDA21D3U, 0xDA3938U, 0xDA427AU, 0xDA5A91U, 0xDA6B44U, 0xDA73AFU, 0xDA852BU, 0xDA9DC0U, 0xDAAC15U, 0xDAB4FEU, + 0xDACFBCU, 0xDAD757U, 0xDAE682U, 0xDAFE69U, 0xDB0B8AU, 0xDB1361U, 0xDB22B4U, 0xDB3A5FU, 0xDB411DU, 0xDB59F6U, + 0xDB6823U, 0xDB70C8U, 0xDB864CU, 0xDB9EA7U, 0xDBAF72U, 0xDBB799U, 0xDBCCDBU, 0xDBD430U, 0xDBE5E5U, 0xDBFD0EU, + 0xDC03B9U, 0xDC1B52U, 0xDC2A87U, 0xDC326CU, 0xDC492EU, 0xDC51C5U, 0xDC6010U, 0xDC78FBU, 0xDC8E7FU, 0xDC9694U, + 0xDCA741U, 0xDCBFAAU, 0xDCC4E8U, 0xDCDC03U, 0xDCEDD6U, 0xDCF53DU, 0xDD00DEU, 0xDD1835U, 0xDD29E0U, 0xDD310BU, + 0xDD4A49U, 0xDD52A2U, 0xDD6377U, 0xDD7B9CU, 0xDD8D18U, 0xDD95F3U, 0xDDA426U, 0xDDBCCDU, 0xDDC78FU, 0xDDDF64U, + 0xDDEEB1U, 0xDDF65AU, 0xDE0574U, 0xDE1D9FU, 0xDE2C4AU, 0xDE34A1U, 0xDE4FE3U, 0xDE5708U, 0xDE66DDU, 0xDE7E36U, + 0xDE88B2U, 0xDE9059U, 0xDEA18CU, 0xDEB967U, 0xDEC225U, 0xDEDACEU, 0xDEEB1BU, 0xDEF3F0U, 0xDF0613U, 0xDF1EF8U, + 0xDF2F2DU, 0xDF37C6U, 0xDF4C84U, 0xDF546FU, 0xDF65BAU, 0xDF7D51U, 0xDF8BD5U, 0xDF933EU, 0xDFA2EBU, 0xDFBA00U, + 0xDFC142U, 0xDFD9A9U, 0xDFE87CU, 0xDFF097U, 0xE00526U, 0xE01DCDU, 0xE02C18U, 0xE034F3U, 0xE04FB1U, 0xE0575AU, + 0xE0668FU, 0xE07E64U, 0xE088E0U, 0xE0900BU, 0xE0A1DEU, 0xE0B935U, 0xE0C277U, 0xE0DA9CU, 0xE0EB49U, 0xE0F3A2U, + 0xE10641U, 0xE11EAAU, 0xE12F7FU, 0xE13794U, 0xE14CD6U, 0xE1543DU, 0xE165E8U, 0xE17D03U, 0xE18B87U, 0xE1936CU, + 0xE1A2B9U, 0xE1BA52U, 0xE1C110U, 0xE1D9FBU, 0xE1E82EU, 0xE1F0C5U, 0xE203EBU, 0xE21B00U, 0xE22AD5U, 0xE2323EU, + 0xE2497CU, 0xE25197U, 0xE26042U, 0xE278A9U, 0xE28E2DU, 0xE296C6U, 0xE2A713U, 0xE2BFF8U, 0xE2C4BAU, 0xE2DC51U, + 0xE2ED84U, 0xE2F56FU, 0xE3008CU, 0xE31867U, 0xE329B2U, 0xE33159U, 0xE34A1BU, 0xE352F0U, 0xE36325U, 0xE37BCEU, + 0xE38D4AU, 0xE395A1U, 0xE3A474U, 0xE3BC9FU, 0xE3C7DDU, 0xE3DF36U, 0xE3EEE3U, 0xE3F608U, 0xE408BFU, 0xE41054U, + 0xE42181U, 0xE4396AU, 0xE44228U, 0xE45AC3U, 0xE46B16U, 0xE473FDU, 0xE48579U, 0xE49D92U, 0xE4AC47U, 0xE4B4ACU, + 0xE4CFEEU, 0xE4D705U, 0xE4E6D0U, 0xE4FE3BU, 0xE50BD8U, 0xE51333U, 0xE522E6U, 0xE53A0DU, 0xE5414FU, 0xE559A4U, + 0xE56871U, 0xE5709AU, 0xE5861EU, 0xE59EF5U, 0xE5AF20U, 0xE5B7CBU, 0xE5CC89U, 0xE5D462U, 0xE5E5B7U, 0xE5FD5CU, + 0xE60E72U, 0xE61699U, 0xE6274CU, 0xE63FA7U, 0xE644E5U, 0xE65C0EU, 0xE66DDBU, 0xE67530U, 0xE683B4U, 0xE69B5FU, + 0xE6AA8AU, 0xE6B261U, 0xE6C923U, 0xE6D1C8U, 0xE6E01DU, 0xE6F8F6U, 0xE70D15U, 0xE715FEU, 0xE7242BU, 0xE73CC0U, + 0xE74782U, 0xE75F69U, 0xE76EBCU, 0xE77657U, 0xE780D3U, 0xE79838U, 0xE7A9EDU, 0xE7B106U, 0xE7CA44U, 0xE7D2AFU, + 0xE7E37AU, 0xE7FB91U, 0xE806FCU, 0xE81E17U, 0xE82FC2U, 0xE83729U, 0xE84C6BU, 0xE85480U, 0xE86555U, 0xE87DBEU, + 0xE88B3AU, 0xE893D1U, 0xE8A204U, 0xE8BAEFU, 0xE8C1ADU, 0xE8D946U, 0xE8E893U, 0xE8F078U, 0xE9059BU, 0xE91D70U, + 0xE92CA5U, 0xE9344EU, 0xE94F0CU, 0xE957E7U, 0xE96632U, 0xE97ED9U, 0xE9885DU, 0xE990B6U, 0xE9A163U, 0xE9B988U, + 0xE9C2CAU, 0xE9DA21U, 0xE9EBF4U, 0xE9F31FU, 0xEA0031U, 0xEA18DAU, 0xEA290FU, 0xEA31E4U, 0xEA4AA6U, 0xEA524DU, + 0xEA6398U, 0xEA7B73U, 0xEA8DF7U, 0xEA951CU, 0xEAA4C9U, 0xEABC22U, 0xEAC760U, 0xEADF8BU, 0xEAEE5EU, 0xEAF6B5U, + 0xEB0356U, 0xEB1BBDU, 0xEB2A68U, 0xEB3283U, 0xEB49C1U, 0xEB512AU, 0xEB60FFU, 0xEB7814U, 0xEB8E90U, 0xEB967BU, + 0xEBA7AEU, 0xEBBF45U, 0xEBC407U, 0xEBDCECU, 0xEBED39U, 0xEBF5D2U, 0xEC0B65U, 0xEC138EU, 0xEC225BU, 0xEC3AB0U, + 0xEC41F2U, 0xEC5919U, 0xEC68CCU, 0xEC7027U, 0xEC86A3U, 0xEC9E48U, 0xECAF9DU, 0xECB776U, 0xECCC34U, 0xECD4DFU, + 0xECE50AU, 0xECFDE1U, 0xED0802U, 0xED10E9U, 0xED213CU, 0xED39D7U, 0xED4295U, 0xED5A7EU, 0xED6BABU, 0xED7340U, + 0xED85C4U, 0xED9D2FU, 0xEDACFAU, 0xEDB411U, 0xEDCF53U, 0xEDD7B8U, 0xEDE66DU, 0xEDFE86U, 0xEE0DA8U, 0xEE1543U, + 0xEE2496U, 0xEE3C7DU, 0xEE473FU, 0xEE5FD4U, 0xEE6E01U, 0xEE76EAU, 0xEE806EU, 0xEE9885U, 0xEEA950U, 0xEEB1BBU, + 0xEECAF9U, 0xEED212U, 0xEEE3C7U, 0xEEFB2CU, 0xEF0ECFU, 0xEF1624U, 0xEF27F1U, 0xEF3F1AU, 0xEF4458U, 0xEF5CB3U, + 0xEF6D66U, 0xEF758DU, 0xEF8309U, 0xEF9BE2U, 0xEFAA37U, 0xEFB2DCU, 0xEFC99EU, 0xEFD175U, 0xEFE0A0U, 0xEFF84BU, + 0xF00292U, 0xF01A79U, 0xF02BACU, 0xF03347U, 0xF04805U, 0xF050EEU, 0xF0613BU, 0xF079D0U, 0xF08F54U, 0xF097BFU, + 0xF0A66AU, 0xF0BE81U, 0xF0C5C3U, 0xF0DD28U, 0xF0ECFDU, 0xF0F416U, 0xF101F5U, 0xF1191EU, 0xF128CBU, 0xF13020U, + 0xF14B62U, 0xF15389U, 0xF1625CU, 0xF17AB7U, 0xF18C33U, 0xF194D8U, 0xF1A50DU, 0xF1BDE6U, 0xF1C6A4U, 0xF1DE4FU, + 0xF1EF9AU, 0xF1F771U, 0xF2045FU, 0xF21CB4U, 0xF22D61U, 0xF2358AU, 0xF24EC8U, 0xF25623U, 0xF267F6U, 0xF27F1DU, + 0xF28999U, 0xF29172U, 0xF2A0A7U, 0xF2B84CU, 0xF2C30EU, 0xF2DBE5U, 0xF2EA30U, 0xF2F2DBU, 0xF30738U, 0xF31FD3U, + 0xF32E06U, 0xF336EDU, 0xF34DAFU, 0xF35544U, 0xF36491U, 0xF37C7AU, 0xF38AFEU, 0xF39215U, 0xF3A3C0U, 0xF3BB2BU, + 0xF3C069U, 0xF3D882U, 0xF3E957U, 0xF3F1BCU, 0xF40F0BU, 0xF417E0U, 0xF42635U, 0xF43EDEU, 0xF4459CU, 0xF45D77U, + 0xF46CA2U, 0xF47449U, 0xF482CDU, 0xF49A26U, 0xF4ABF3U, 0xF4B318U, 0xF4C85AU, 0xF4D0B1U, 0xF4E164U, 0xF4F98FU, + 0xF50C6CU, 0xF51487U, 0xF52552U, 0xF53DB9U, 0xF546FBU, 0xF55E10U, 0xF56FC5U, 0xF5772EU, 0xF581AAU, 0xF59941U, + 0xF5A894U, 0xF5B07FU, 0xF5CB3DU, 0xF5D3D6U, 0xF5E203U, 0xF5FAE8U, 0xF609C6U, 0xF6112DU, 0xF620F8U, 0xF63813U, + 0xF64351U, 0xF65BBAU, 0xF66A6FU, 0xF67284U, 0xF68400U, 0xF69CEBU, 0xF6AD3EU, 0xF6B5D5U, 0xF6CE97U, 0xF6D67CU, + 0xF6E7A9U, 0xF6FF42U, 0xF70AA1U, 0xF7124AU, 0xF7239FU, 0xF73B74U, 0xF74036U, 0xF758DDU, 0xF76908U, 0xF771E3U, + 0xF78767U, 0xF79F8CU, 0xF7AE59U, 0xF7B6B2U, 0xF7CDF0U, 0xF7D51BU, 0xF7E4CEU, 0xF7FC25U, 0xF80148U, 0xF819A3U, + 0xF82876U, 0xF8309DU, 0xF84BDFU, 0xF85334U, 0xF862E1U, 0xF87A0AU, 0xF88C8EU, 0xF89465U, 0xF8A5B0U, 0xF8BD5BU, + 0xF8C619U, 0xF8DEF2U, 0xF8EF27U, 0xF8F7CCU, 0xF9022FU, 0xF91AC4U, 0xF92B11U, 0xF933FAU, 0xF948B8U, 0xF95053U, + 0xF96186U, 0xF9796DU, 0xF98FE9U, 0xF99702U, 0xF9A6D7U, 0xF9BE3CU, 0xF9C57EU, 0xF9DD95U, 0xF9EC40U, 0xF9F4ABU, + 0xFA0785U, 0xFA1F6EU, 0xFA2EBBU, 0xFA3650U, 0xFA4D12U, 0xFA55F9U, 0xFA642CU, 0xFA7CC7U, 0xFA8A43U, 0xFA92A8U, + 0xFAA37DU, 0xFABB96U, 0xFAC0D4U, 0xFAD83FU, 0xFAE9EAU, 0xFAF101U, 0xFB04E2U, 0xFB1C09U, 0xFB2DDCU, 0xFB3537U, + 0xFB4E75U, 0xFB569EU, 0xFB674BU, 0xFB7FA0U, 0xFB8924U, 0xFB91CFU, 0xFBA01AU, 0xFBB8F1U, 0xFBC3B3U, 0xFBDB58U, + 0xFBEA8DU, 0xFBF266U, 0xFC0CD1U, 0xFC143AU, 0xFC25EFU, 0xFC3D04U, 0xFC4646U, 0xFC5EADU, 0xFC6F78U, 0xFC7793U, + 0xFC8117U, 0xFC99FCU, 0xFCA829U, 0xFCB0C2U, 0xFCCB80U, 0xFCD36BU, 0xFCE2BEU, 0xFCFA55U, 0xFD0FB6U, 0xFD175DU, + 0xFD2688U, 0xFD3E63U, 0xFD4521U, 0xFD5DCAU, 0xFD6C1FU, 0xFD74F4U, 0xFD8270U, 0xFD9A9BU, 0xFDAB4EU, 0xFDB3A5U, + 0xFDC8E7U, 0xFDD00CU, 0xFDE1D9U, 0xFDF932U, 0xFE0A1CU, 0xFE12F7U, 0xFE2322U, 0xFE3BC9U, 0xFE408BU, 0xFE5860U, + 0xFE69B5U, 0xFE715EU, 0xFE87DAU, 0xFE9F31U, 0xFEAEE4U, 0xFEB60FU, 0xFECD4DU, 0xFED5A6U, 0xFEE473U, 0xFEFC98U, + 0xFF097BU, 0xFF1190U, 0xFF2045U, 0xFF38AEU, 0xFF43ECU, 0xFF5B07U, 0xFF6AD2U, 0xFF7239U, 0xFF84BDU, 0xFF9C56U, + 0xFFAD83U, 0xFFB568U, 0xFFCE2AU, 0xFFD6C1U, 0xFFE714U, 0xFFFFFFU}; + +static const unsigned int DECODING_TABLE_23127[] = { + 0x000000U, 0x000001U, 0x000002U, 0x000003U, 0x000004U, 0x000005U, 0x000006U, 0x000007U, 0x000008U, 0x000009U, + 0x00000AU, 0x00000BU, 0x00000CU, 0x00000DU, 0x00000EU, 0x024020U, 0x000010U, 0x000011U, 0x000012U, 0x000013U, + 0x000014U, 0x000015U, 0x000016U, 0x412000U, 0x000018U, 0x000019U, 0x00001AU, 0x180800U, 0x00001CU, 0x200300U, + 0x048040U, 0x001480U, 0x000020U, 0x000021U, 0x000022U, 0x000023U, 0x000024U, 0x000025U, 0x000026U, 0x024008U, + 0x000028U, 0x000029U, 0x00002AU, 0x024004U, 0x00002CU, 0x024002U, 0x024001U, 0x024000U, 0x000030U, 0x000031U, + 0x000032U, 0x008180U, 0x000034U, 0x000C40U, 0x301000U, 0x0C0200U, 0x000038U, 0x043000U, 0x400600U, 0x210040U, + 0x090080U, 0x508000U, 0x002900U, 0x024010U, 0x000040U, 0x000041U, 0x000042U, 0x000043U, 0x000044U, 0x000045U, + 0x000046U, 0x280080U, 0x000048U, 0x000049U, 0x00004AU, 0x002500U, 0x00004CU, 0x111000U, 0x048010U, 0x400A00U, + 0x000050U, 0x000051U, 0x000052U, 0x021200U, 0x000054U, 0x000C20U, 0x048008U, 0x104100U, 0x000058U, 0x404080U, + 0x048004U, 0x210020U, 0x048002U, 0x0A2000U, 0x048000U, 0x048001U, 0x000060U, 0x000061U, 0x000062U, 0x540000U, + 0x000064U, 0x000C10U, 0x010300U, 0x00B000U, 0x000068U, 0x088200U, 0x001880U, 0x210010U, 0x602000U, 0x040180U, + 0x180400U, 0x024040U, 0x000070U, 0x000C04U, 0x086000U, 0x210008U, 0x000C01U, 0x000C00U, 0x420080U, 0x000C02U, + 0x120100U, 0x210002U, 0x210001U, 0x210000U, 0x005200U, 0x000C08U, 0x048020U, 0x210004U, 0x000080U, 0x000081U, + 0x000082U, 0x000083U, 0x000084U, 0x000085U, 0x000086U, 0x280040U, 0x000088U, 0x000089U, 0x00008AU, 0x050200U, + 0x00008CU, 0x00A800U, 0x500100U, 0x001410U, 0x000090U, 0x000091U, 0x000092U, 0x008120U, 0x000094U, 0x160000U, + 0x004A00U, 0x001408U, 0x000098U, 0x404040U, 0x222000U, 0x001404U, 0x090020U, 0x001402U, 0x001401U, 0x001400U, + 0x0000A0U, 0x0000A1U, 0x0000A2U, 0x008110U, 0x0000A4U, 0x401200U, 0x042400U, 0x110800U, 0x0000A8U, 0x300400U, + 0x001840U, 0x482000U, 0x090010U, 0x040140U, 0x208200U, 0x024080U, 0x0000B0U, 0x008102U, 0x008101U, 0x008100U, + 0x090008U, 0x206000U, 0x420040U, 0x008104U, 0x090004U, 0x020A00U, 0x144000U, 0x008108U, 0x090000U, 0x090001U, + 0x090002U, 0x001420U, 0x0000C0U, 0x0000C1U, 0x0000C2U, 0x280004U, 0x0000C4U, 0x280002U, 0x280001U, 0x280000U, + 0x0000C8U, 0x404010U, 0x001820U, 0x128000U, 0x020600U, 0x040120U, 0x016000U, 0x280008U, 0x0000D0U, 0x404008U, + 0x110400U, 0x042800U, 0x003100U, 0x018200U, 0x420020U, 0x280010U, 0x404001U, 0x404000U, 0x080300U, 0x404002U, + 0x300800U, 0x404004U, 0x048080U, 0x001440U, 0x0000E0U, 0x032000U, 0x001808U, 0x004600U, 0x10C000U, 0x040108U, + 0x420010U, 0x280020U, 0x001802U, 0x040104U, 0x001800U, 0x001801U, 0x040101U, 0x040100U, 0x001804U, 0x040102U, + 0x240200U, 0x181000U, 0x420004U, 0x008140U, 0x420002U, 0x000C80U, 0x420000U, 0x420001U, 0x00A400U, 0x404020U, + 0x001810U, 0x210080U, 0x090040U, 0x040110U, 0x420008U, 0x102200U, 0x000100U, 0x000101U, 0x000102U, 0x000103U, + 0x000104U, 0x000105U, 0x000106U, 0x041800U, 0x000108U, 0x000109U, 0x00010AU, 0x002440U, 0x00010CU, 0x200210U, + 0x500080U, 0x098000U, 0x000110U, 0x000111U, 0x000112U, 0x0080A0U, 0x000114U, 0x200208U, 0x0A0400U, 0x104040U, + 0x000118U, 0x200204U, 0x015000U, 0x460000U, 0x200201U, 0x200200U, 0x002820U, 0x200202U, 0x000120U, 0x000121U, + 0x000122U, 0x008090U, 0x000124U, 0x182000U, 0x010240U, 0x600400U, 0x000128U, 0x410800U, 0x2C0000U, 0x101200U, + 0x009400U, 0x0400C0U, 0x002810U, 0x024100U, 0x000130U, 0x008082U, 0x008081U, 0x008080U, 0x444000U, 0x031000U, + 0x002808U, 0x008084U, 0x120040U, 0x084400U, 0x002804U, 0x008088U, 0x002802U, 0x200220U, 0x002800U, 0x002801U, + 0x000140U, 0x000141U, 0x000142U, 0x002408U, 0x000144U, 0x428000U, 0x010220U, 0x104010U, 0x000148U, 0x002402U, + 0x002401U, 0x002400U, 0x084800U, 0x0400A0U, 0x221000U, 0x002404U, 0x000150U, 0x0D0000U, 0x600800U, 0x104004U, + 0x003080U, 0x104002U, 0x104001U, 0x104000U, 0x120020U, 0x009800U, 0x080280U, 0x002410U, 0x410400U, 0x200240U, + 0x048100U, 0x104008U, 0x000160U, 0x205000U, 0x010204U, 0x0A0800U, 0x010202U, 0x040088U, 0x010200U, 0x010201U, + 0x120010U, 0x040084U, 0x40C000U, 0x002420U, 0x040081U, 0x040080U, 0x010208U, 0x040082U, 0x120008U, 0x402200U, + 0x041400U, 0x0080C0U, 0x288000U, 0x000D00U, 0x010210U, 0x104020U, 0x120000U, 0x120001U, 0x120002U, 0x210100U, + 0x120004U, 0x040090U, 0x002840U, 0x481000U, 0x000180U, 0x000181U, 0x000182U, 0x008030U, 0x000184U, 0x014400U, + 0x500008U, 0x022200U, 0x000188U, 0x0A1000U, 0x500004U, 0x204800U, 0x500002U, 0x040060U, 0x500000U, 0x500001U, + 0x000190U, 0x008022U, 0x008021U, 0x008020U, 0x003040U, 0x480800U, 0x250000U, 0x008024U, 0x040C00U, 0x112000U, + 0x080240U, 0x008028U, 0x02C000U, 0x200280U, 0x500010U, 0x001500U, 0x0001A0U, 0x008012U, 0x008011U, 0x008010U, + 0x220800U, 0x040048U, 0x085000U, 0x008014U, 0x006200U, 0x040044U, 0x030400U, 0x008018U, 0x040041U, 0x040040U, + 0x500020U, 0x040042U, 0x008003U, 0x008002U, 0x008001U, 0x008000U, 0x100600U, 0x008006U, 0x008005U, 0x008004U, + 0x601000U, 0x00800AU, 0x008009U, 0x008008U, 0x090100U, 0x040050U, 0x002880U, 0x00800CU, 0x0001C0U, 0x100A00U, + 0x064000U, 0x411000U, 0x003010U, 0x040028U, 0x008C00U, 0x280100U, 0x218000U, 0x040024U, 0x080210U, 0x002480U, + 0x040021U, 0x040020U, 0x500040U, 0x040022U, 0x003004U, 0x220400U, 0x080208U, 0x008060U, 0x003000U, 0x003001U, + 0x003002U, 0x104080U, 0x080202U, 0x404100U, 0x080200U, 0x080201U, 0x003008U, 0x040030U, 0x080204U, 0x030800U, + 0x480400U, 0x04000CU, 0x302000U, 0x008050U, 0x040009U, 0x040008U, 0x010280U, 0x04000AU, 0x040005U, 0x040004U, + 0x001900U, 0x040006U, 0x040001U, 0x040000U, 0x040003U, 0x040002U, 0x014800U, 0x008042U, 0x008041U, 0x008040U, + 0x003020U, 0x040018U, 0x420100U, 0x008044U, 0x120080U, 0x040014U, 0x080220U, 0x008048U, 0x040011U, 0x040010U, + 0x204400U, 0x040012U, 0x000200U, 0x000201U, 0x000202U, 0x000203U, 0x000204U, 0x000205U, 0x000206U, 0x108400U, + 0x000208U, 0x000209U, 0x00020AU, 0x050080U, 0x00020CU, 0x200110U, 0x083000U, 0x400840U, 0x000210U, 0x000211U, + 0x000212U, 0x021040U, 0x000214U, 0x200108U, 0x004880U, 0x0C0020U, 0x000218U, 0x200104U, 0x400420U, 0x00E000U, + 0x200101U, 0x200100U, 0x130000U, 0x200102U, 0x000220U, 0x000221U, 0x000222U, 0x202800U, 0x000224U, 0x401080U, + 0x010140U, 0x0C0010U, 0x000228U, 0x088040U, 0x400410U, 0x101100U, 0x140800U, 0x012400U, 0x208080U, 0x024200U, + 0x000230U, 0x114000U, 0x400408U, 0x0C0004U, 0x02A000U, 0x0C0002U, 0x0C0001U, 0x0C0000U, 0x400402U, 0x020880U, + 0x400400U, 0x400401U, 0x005040U, 0x200120U, 0x400404U, 0x0C0008U, 0x000240U, 0x000241U, 0x000242U, 0x021010U, + 0x000244U, 0x046000U, 0x010120U, 0x400808U, 0x000248U, 0x088020U, 0x304000U, 0x400804U, 0x020480U, 0x400802U, + 0x400801U, 0x400800U, 0x000250U, 0x021002U, 0x021001U, 0x021000U, 0x580000U, 0x018080U, 0x202400U, 0x021004U, + 0x012800U, 0x140400U, 0x080180U, 0x021008U, 0x005020U, 0x200140U, 0x048200U, 0x400810U, 0x000260U, 0x088008U, + 0x010104U, 0x004480U, 0x010102U, 0x320000U, 0x010100U, 0x010101U, 0x088001U, 0x088000U, 0x062000U, 0x088002U, + 0x005010U, 0x088004U, 0x010108U, 0x400820U, 0x240080U, 0x402100U, 0x108800U, 0x021020U, 0x005008U, 0x000E00U, + 0x010110U, 0x0C0040U, 0x005004U, 0x088010U, 0x400440U, 0x210200U, 0x005000U, 0x005001U, 0x005002U, 0x102080U, + 0x000280U, 0x000281U, 0x000282U, 0x050008U, 0x000284U, 0x401020U, 0x004810U, 0x022100U, 0x000288U, 0x050002U, + 0x050001U, 0x050000U, 0x020440U, 0x184000U, 0x208020U, 0x050004U, 0x000290U, 0x082400U, 0x004804U, 0x700000U, + 0x004802U, 0x018040U, 0x004800U, 0x004801U, 0x109000U, 0x020820U, 0x080140U, 0x050010U, 0x442000U, 0x200180U, + 0x004808U, 0x001600U, 0x0002A0U, 0x401004U, 0x1A0000U, 0x004440U, 0x401001U, 0x401000U, 0x208008U, 0x401002U, + 0x006100U, 0x020810U, 0x208004U, 0x050020U, 0x208002U, 0x401008U, 0x208000U, 0x208001U, 0x240040U, 0x020808U, + 0x013000U, 0x008300U, 0x100500U, 0x401010U, 0x004820U, 0x0C0080U, 0x020801U, 0x020800U, 0x400480U, 0x020802U, + 0x090200U, 0x020804U, 0x208010U, 0x102040U, 0x0002C0U, 0x100900U, 0x40A000U, 0x004420U, 0x020408U, 0x018010U, + 0x141000U, 0x280200U, 0x020404U, 0x203000U, 0x080110U, 0x050040U, 0x020400U, 0x020401U, 0x020402U, 0x400880U, + 0x240020U, 0x018004U, 0x080108U, 0x021080U, 0x018001U, 0x018000U, 0x004840U, 0x018002U, 0x080102U, 0x404200U, + 0x080100U, 0x080101U, 0x020410U, 0x018008U, 0x080104U, 0x102020U, 0x240010U, 0x004402U, 0x004401U, 0x004400U, + 0x082800U, 0x401040U, 0x010180U, 0x004404U, 0x510000U, 0x088080U, 0x001A00U, 0x004408U, 0x020420U, 0x040300U, + 0x208040U, 0x102010U, 0x240000U, 0x240001U, 0x240002U, 0x004410U, 0x240004U, 0x018020U, 0x420200U, 0x102008U, + 0x240008U, 0x020840U, 0x080120U, 0x102004U, 0x005080U, 0x102002U, 0x102001U, 0x102000U, 0x000300U, 0x000301U, + 0x000302U, 0x484000U, 0x000304U, 0x200018U, 0x010060U, 0x022080U, 0x000308U, 0x200014U, 0x028800U, 0x101020U, + 0x200011U, 0x200010U, 0x044400U, 0x200012U, 0x000310U, 0x20000CU, 0x142000U, 0x010C00U, 0x200009U, 0x200008U, + 0x409000U, 0x20000AU, 0x200005U, 0x200004U, 0x0800C0U, 0x200006U, 0x200001U, 0x200000U, 0x200003U, 0x200002U, + 0x000320U, 0x060400U, 0x010044U, 0x101008U, 0x010042U, 0x00C800U, 0x010040U, 0x010041U, 0x006080U, 0x101002U, + 0x101001U, 0x101000U, 0x4A0000U, 0x200030U, 0x010048U, 0x101004U, 0x081800U, 0x402040U, 0x224000U, 0x008280U, + 0x100480U, 0x200028U, 0x010050U, 0x0C0100U, 0x058000U, 0x200024U, 0x400500U, 0x101010U, 0x200021U, 0x200020U, + 0x002A00U, 0x200022U, 0x000340U, 0x100880U, 0x010024U, 0x248000U, 0x010022U, 0x081400U, 0x010020U, 0x010021U, + 0x441000U, 0x034000U, 0x080090U, 0x002600U, 0x10A000U, 0x200050U, 0x010028U, 0x400900U, 0x00C400U, 0x402020U, + 0x080088U, 0x021100U, 0x060800U, 0x200048U, 0x010030U, 0x104200U, 0x080082U, 0x200044U, 0x080080U, 0x080081U, + 0x200041U, 0x200040U, 0x080084U, 0x200042U, 0x010006U, 0x402010U, 0x010004U, 0x010005U, 0x010002U, 0x010003U, + 0x010000U, 0x010001U, 0x200C00U, 0x088100U, 0x01000CU, 0x101040U, 0x01000AU, 0x040280U, 0x010008U, 0x010009U, + 0x402001U, 0x402000U, 0x010014U, 0x402002U, 0x010012U, 0x402004U, 0x010010U, 0x010011U, 0x120200U, 0x402008U, + 0x0800A0U, 0x044800U, 0x005100U, 0x200060U, 0x010018U, 0x028400U, 0x000380U, 0x100840U, 0x201400U, 0x022004U, + 0x0C8000U, 0x022002U, 0x022001U, 0x022000U, 0x006020U, 0x408400U, 0x080050U, 0x050100U, 0x011800U, 0x200090U, + 0x500200U, 0x022008U, 0x430000U, 0x045000U, 0x080048U, 0x008220U, 0x100420U, 0x200088U, 0x004900U, 0x022010U, + 0x080042U, 0x200084U, 0x080040U, 0x080041U, 0x200081U, 0x200080U, 0x080044U, 0x200082U, 0x006008U, 0x290000U, + 0x440800U, 0x008210U, 0x100410U, 0x401100U, 0x0100C0U, 0x022020U, 0x006000U, 0x006001U, 0x006002U, 0x101080U, + 0x006004U, 0x040240U, 0x208100U, 0x080C00U, 0x100404U, 0x008202U, 0x008201U, 0x008200U, 0x100400U, 0x100401U, + 0x100402U, 0x008204U, 0x006010U, 0x020900U, 0x080060U, 0x008208U, 0x100408U, 0x2000A0U, 0x061000U, 0x414000U, + 0x100801U, 0x100800U, 0x080018U, 0x100802U, 0x604000U, 0x100804U, 0x0100A0U, 0x022040U, 0x080012U, 0x100808U, + 0x080010U, 0x080011U, 0x020500U, 0x040220U, 0x080014U, 0x00D000U, 0x08000AU, 0x100810U, 0x080008U, 0x080009U, + 0x003200U, 0x018100U, 0x08000CU, 0x440400U, 0x080002U, 0x080003U, 0x080000U, 0x080001U, 0x080006U, 0x2000C0U, + 0x080004U, 0x080005U, 0x029000U, 0x100820U, 0x010084U, 0x004500U, 0x010082U, 0x040208U, 0x010080U, 0x010081U, + 0x006040U, 0x040204U, 0x080030U, 0x620000U, 0x040201U, 0x040200U, 0x010088U, 0x040202U, 0x240100U, 0x402080U, + 0x080028U, 0x008240U, 0x100440U, 0x0A4000U, 0x010090U, 0x201800U, 0x080022U, 0x011400U, 0x080020U, 0x080021U, + 0x408800U, 0x040210U, 0x080024U, 0x102100U, 0x000400U, 0x000401U, 0x000402U, 0x000403U, 0x000404U, 0x000405U, + 0x000406U, 0x108200U, 0x000408U, 0x000409U, 0x00040AU, 0x002140U, 0x00040CU, 0x4C0000U, 0x210800U, 0x001090U, + 0x000410U, 0x000411U, 0x000412U, 0x244000U, 0x000414U, 0x000860U, 0x0A0100U, 0x001088U, 0x000418U, 0x038000U, + 0x400220U, 0x001084U, 0x106000U, 0x001082U, 0x001081U, 0x001080U, 0x000420U, 0x000421U, 0x000422U, 0x091000U, + 0x000424U, 0x000850U, 0x042080U, 0x600100U, 0x000428U, 0x300080U, 0x400210U, 0x048800U, 0x009100U, 0x012200U, + 0x180040U, 0x024400U, 0x000430U, 0x000844U, 0x400208U, 0x122000U, 0x000841U, 0x000840U, 0x01C000U, 0x000842U, + 0x400202U, 0x084100U, 0x400200U, 0x400201U, 0x260000U, 0x000848U, 0x400204U, 0x0010A0U, 0x000440U, 0x000441U, + 0x000442U, 0x002108U, 0x000444U, 0x000830U, 0x405000U, 0x070000U, 0x000448U, 0x002102U, 0x002101U, 0x002100U, + 0x020280U, 0x20C000U, 0x180020U, 0x002104U, 0x000450U, 0x000824U, 0x110080U, 0x488000U, 0x000821U, 0x000820U, + 0x202200U, 0x000822U, 0x281000U, 0x140200U, 0x024800U, 0x002110U, 0x410100U, 0x000828U, 0x048400U, 0x0010C0U, + 0x000460U, 0x000814U, 0x228000U, 0x004280U, 0x000811U, 0x000810U, 0x180008U, 0x000812U, 0x054000U, 0x421000U, + 0x180004U, 0x002120U, 0x180002U, 0x000818U, 0x180000U, 0x180001U, 0x000805U, 0x000804U, 0x041100U, 0x000806U, + 0x000801U, 0x000800U, 0x000803U, 0x000802U, 0x00A080U, 0x00080CU, 0x400240U, 0x210400U, 0x000809U, 0x000808U, + 0x180010U, 0x00080AU, 0x000480U, 0x000481U, 0x000482U, 0x420800U, 0x000484U, 0x014100U, 0x042020U, 0x001018U, + 0x000488U, 0x300020U, 0x08C000U, 0x001014U, 0x020240U, 0x001012U, 0x001011U, 0x001010U, 0x000490U, 0x082200U, + 0x110040U, 0x00100CU, 0x608000U, 0x00100AU, 0x001009U, 0x001008U, 0x040900U, 0x001006U, 0x001005U, 0x001004U, + 0x001003U, 0x001002U, 0x001001U, 0x001000U, 0x0004A0U, 0x300008U, 0x042004U, 0x004240U, 0x042002U, 0x0A8000U, + 0x042000U, 0x042001U, 0x300001U, 0x300000U, 0x030100U, 0x300002U, 0x404800U, 0x300004U, 0x042008U, 0x001030U, + 0x025000U, 0x450000U, 0x280800U, 0x008500U, 0x100300U, 0x0008C0U, 0x042010U, 0x001028U, 0x00A040U, 0x300010U, + 0x400280U, 0x001024U, 0x090400U, 0x001022U, 0x001021U, 0x001020U, 0x0004C0U, 0x049000U, 0x110010U, 0x004220U, + 0x020208U, 0x502000U, 0x008900U, 0x280400U, 0x020204U, 0x090800U, 0x640000U, 0x002180U, 0x020200U, 0x020201U, + 0x020202U, 0x001050U, 0x110002U, 0x220100U, 0x110000U, 0x110001U, 0x0C4000U, 0x0008A0U, 0x110004U, 0x001048U, + 0x00A020U, 0x404400U, 0x110008U, 0x001044U, 0x020210U, 0x001042U, 0x001041U, 0x001040U, 0x480100U, 0x004202U, + 0x004201U, 0x004200U, 0x211000U, 0x000890U, 0x042040U, 0x004204U, 0x00A010U, 0x300040U, 0x001C00U, 0x004208U, + 0x020220U, 0x040500U, 0x180080U, 0x418000U, 0x00A008U, 0x000884U, 0x110020U, 0x004210U, 0x000881U, 0x000880U, + 0x420400U, 0x000882U, 0x00A000U, 0x00A001U, 0x00A002U, 0x0E0000U, 0x00A004U, 0x000888U, 0x204100U, 0x001060U, + 0x000500U, 0x000501U, 0x000502U, 0x002048U, 0x000504U, 0x014080U, 0x0A0010U, 0x600020U, 0x000508U, 0x002042U, + 0x002041U, 0x002040U, 0x009020U, 0x120800U, 0x044200U, 0x002044U, 0x000510U, 0x501000U, 0x0A0004U, 0x010A00U, + 0x0A0002U, 0x04A000U, 0x0A0000U, 0x0A0001U, 0x040880U, 0x084020U, 0x308000U, 0x002050U, 0x410040U, 0x200600U, + 0x0A0008U, 0x001180U, 0x000520U, 0x060200U, 0x104800U, 0x600004U, 0x009008U, 0x600002U, 0x600001U, 0x600000U, + 0x009004U, 0x084010U, 0x030080U, 0x002060U, 0x009000U, 0x009001U, 0x009002U, 0x600008U, 0x212000U, 0x084008U, + 0x041040U, 0x008480U, 0x100280U, 0x000940U, 0x0A0020U, 0x600010U, 0x084001U, 0x084000U, 0x400300U, 0x084002U, + 0x009010U, 0x084004U, 0x002C00U, 0x150000U, 0x000540U, 0x00200AU, 0x002009U, 0x002008U, 0x340000U, 0x081200U, + 0x008880U, 0x00200CU, 0x002003U, 0x002002U, 0x002001U, 0x002000U, 0x410010U, 0x002006U, 0x002005U, 0x002004U, + 0x00C200U, 0x220080U, 0x041020U, 0x002018U, 0x410008U, 0x000920U, 0x0A0040U, 0x104400U, 0x410004U, 0x002012U, + 0x002011U, 0x002010U, 0x410000U, 0x410001U, 0x410002U, 0x002014U, 0x480080U, 0x118000U, 0x041010U, 0x002028U, + 0x026000U, 0x000910U, 0x010600U, 0x600040U, 0x200A00U, 0x002022U, 0x002021U, 0x002020U, 0x009040U, 0x040480U, + 0x180100U, 0x002024U, 0x041002U, 0x000904U, 0x041000U, 0x041001U, 0x000901U, 0x000900U, 0x041004U, 0x000902U, + 0x120400U, 0x084040U, 0x041008U, 0x002030U, 0x410020U, 0x000908U, 0x204080U, 0x028200U, 0x000580U, 0x014004U, + 0x201200U, 0x1C0000U, 0x014001U, 0x014000U, 0x008840U, 0x014002U, 0x040810U, 0x408200U, 0x030020U, 0x0020C0U, + 0x282000U, 0x014008U, 0x500400U, 0x001110U, 0x040808U, 0x220040U, 0x406000U, 0x008420U, 0x100220U, 0x014010U, + 0x0A0080U, 0x001108U, 0x040800U, 0x040801U, 0x040802U, 0x001104U, 0x040804U, 0x001102U, 0x001101U, 0x001100U, + 0x480040U, 0x003800U, 0x030008U, 0x008410U, 0x100210U, 0x014020U, 0x042100U, 0x600080U, 0x030002U, 0x300100U, + 0x030000U, 0x030001U, 0x009080U, 0x040440U, 0x030004U, 0x080A00U, 0x100204U, 0x008402U, 0x008401U, 0x008400U, + 0x100200U, 0x100201U, 0x100202U, 0x008404U, 0x040820U, 0x084080U, 0x030010U, 0x008408U, 0x100208U, 0x422000U, + 0x204040U, 0x001120U, 0x480020U, 0x220010U, 0x008804U, 0x002088U, 0x008802U, 0x014040U, 0x008800U, 0x008801U, + 0x105000U, 0x002082U, 0x002081U, 0x002080U, 0x020300U, 0x040420U, 0x008808U, 0x002084U, 0x220001U, 0x220000U, + 0x110100U, 0x220002U, 0x003400U, 0x220004U, 0x008810U, 0x440200U, 0x040840U, 0x220008U, 0x080600U, 0x002090U, + 0x410080U, 0x188000U, 0x204020U, 0x001140U, 0x480000U, 0x480001U, 0x480002U, 0x004300U, 0x480004U, 0x040408U, + 0x008820U, 0x121000U, 0x480008U, 0x040404U, 0x030040U, 0x0020A0U, 0x040401U, 0x040400U, 0x204010U, 0x040402U, + 0x480010U, 0x220020U, 0x041080U, 0x008440U, 0x100240U, 0x000980U, 0x204008U, 0x092000U, 0x00A100U, 0x011200U, + 0x204004U, 0x500800U, 0x204002U, 0x040410U, 0x204000U, 0x204001U, 0x000600U, 0x000601U, 0x000602U, 0x108004U, + 0x000604U, 0x108002U, 0x108001U, 0x108000U, 0x000608U, 0x005800U, 0x400030U, 0x2A0000U, 0x0200C0U, 0x012020U, + 0x044100U, 0x108008U, 0x000610U, 0x082080U, 0x400028U, 0x010900U, 0x051000U, 0x424000U, 0x202040U, 0x108010U, + 0x400022U, 0x140040U, 0x400020U, 0x400021U, 0x088800U, 0x200500U, 0x400024U, 0x001280U, 0x000620U, 0x060100U, + 0x400018U, 0x0040C0U, 0x284000U, 0x012008U, 0x021800U, 0x108020U, 0x400012U, 0x012004U, 0x400010U, 0x400011U, + 0x012001U, 0x012000U, 0x400014U, 0x012002U, 0x40000AU, 0x209000U, 0x400008U, 0x400009U, 0x100180U, 0x000A40U, + 0x40000CU, 0x0C0400U, 0x400002U, 0x400003U, 0x400000U, 0x400001U, 0x400006U, 0x012010U, 0x400004U, 0x400005U, + 0x000640U, 0x610000U, 0x0C0800U, 0x0040A0U, 0x020088U, 0x081100U, 0x202010U, 0x108040U, 0x020084U, 0x140010U, + 0x019000U, 0x002300U, 0x020080U, 0x020081U, 0x020082U, 0x400C00U, 0x00C100U, 0x140008U, 0x202004U, 0x021400U, + 0x202002U, 0x000A20U, 0x202000U, 0x202001U, 0x140001U, 0x140000U, 0x400060U, 0x140002U, 0x020090U, 0x140004U, + 0x202008U, 0x094000U, 0x103000U, 0x004082U, 0x004081U, 0x004080U, 0x448000U, 0x000A10U, 0x010500U, 0x004084U, + 0x200900U, 0x088400U, 0x400050U, 0x004088U, 0x0200A0U, 0x012040U, 0x180200U, 0x241000U, 0x0B0000U, 0x000A04U, + 0x400048U, 0x004090U, 0x000A01U, 0x000A00U, 0x202020U, 0x000A02U, 0x400042U, 0x140020U, 0x400040U, 0x400041U, + 0x005400U, 0x000A08U, 0x400044U, 0x028100U, 0x000680U, 0x082010U, 0x201100U, 0x004060U, 0x020048U, 0x240800U, + 0x490000U, 0x108080U, 0x020044U, 0x408100U, 0x102800U, 0x050400U, 0x020040U, 0x020041U, 0x020042U, 0x001210U, + 0x082001U, 0x082000U, 0x068000U, 0x082002U, 0x100120U, 0x082004U, 0x004C00U, 0x001208U, 0x214000U, 0x082008U, + 0x4000A0U, 0x001204U, 0x020050U, 0x001202U, 0x001201U, 0x001200U, 0x018800U, 0x004042U, 0x004041U, 0x004040U, + 0x100110U, 0x401400U, 0x042200U, 0x004044U, 0x0C1000U, 0x300200U, 0x400090U, 0x004048U, 0x020060U, 0x012080U, + 0x208400U, 0x080900U, 0x100104U, 0x082020U, 0x400088U, 0x004050U, 0x100100U, 0x100101U, 0x100102U, 0x230000U, + 0x400082U, 0x020C00U, 0x400080U, 0x400081U, 0x100108U, 0x04C000U, 0x400084U, 0x001220U, 0x02000CU, 0x004022U, + 0x004021U, 0x004020U, 0x020008U, 0x020009U, 0x02000AU, 0x004024U, 0x020004U, 0x020005U, 0x020006U, 0x004028U, + 0x020000U, 0x020001U, 0x020002U, 0x020003U, 0x401800U, 0x082040U, 0x110200U, 0x004030U, 0x020018U, 0x018400U, + 0x202080U, 0x440100U, 0x020014U, 0x140080U, 0x080500U, 0x208800U, 0x020010U, 0x020011U, 0x020012U, 0x001240U, + 0x004003U, 0x004002U, 0x004001U, 0x004000U, 0x020028U, 0x004006U, 0x004005U, 0x004004U, 0x020024U, 0x00400AU, + 0x004009U, 0x004008U, 0x020020U, 0x020021U, 0x020022U, 0x00400CU, 0x240400U, 0x004012U, 0x004011U, 0x004010U, + 0x100140U, 0x000A80U, 0x089000U, 0x004014U, 0x00A200U, 0x011100U, 0x4000C0U, 0x004018U, 0x020030U, 0x680000U, + 0x050800U, 0x102400U, 0x000700U, 0x060020U, 0x201080U, 0x010810U, 0x402800U, 0x081040U, 0x044008U, 0x108100U, + 0x190000U, 0x408080U, 0x044004U, 0x002240U, 0x044002U, 0x200410U, 0x044000U, 0x044001U, 0x00C040U, 0x010802U, + 0x010801U, 0x010800U, 0x1000A0U, 0x200408U, 0x0A0200U, 0x010804U, 0x023000U, 0x200404U, 0x400120U, 0x010808U, + 0x200401U, 0x200400U, 0x044010U, 0x200402U, 0x060001U, 0x060000U, 0x08A000U, 0x060002U, 0x100090U, 0x060004U, + 0x010440U, 0x600200U, 0x200840U, 0x060008U, 0x400110U, 0x101400U, 0x009200U, 0x012100U, 0x044020U, 0x080880U, + 0x100084U, 0x060010U, 0x400108U, 0x010820U, 0x100080U, 0x100081U, 0x100082U, 0x007000U, 0x400102U, 0x084200U, + 0x400100U, 0x400101U, 0x100088U, 0x200420U, 0x400104U, 0x028040U, 0x00C010U, 0x081004U, 0x520000U, 0x002208U, + 0x081001U, 0x081000U, 0x010420U, 0x081002U, 0x200820U, 0x002202U, 0x002201U, 0x002200U, 0x020180U, 0x081008U, + 0x044040U, 0x002204U, 0x00C000U, 0x00C001U, 0x00C002U, 0x010840U, 0x00C004U, 0x081010U, 0x202100U, 0x440080U, + 0x00C008U, 0x140100U, 0x080480U, 0x002210U, 0x410200U, 0x200440U, 0x101800U, 0x028020U, 0x200808U, 0x060040U, + 0x010404U, 0x004180U, 0x010402U, 0x081020U, 0x010400U, 0x010401U, 0x200800U, 0x200801U, 0x200802U, 0x002220U, + 0x200804U, 0x504000U, 0x010408U, 0x028010U, 0x00C020U, 0x402400U, 0x041200U, 0x380000U, 0x1000C0U, 0x000B00U, + 0x010410U, 0x028008U, 0x200810U, 0x011080U, 0x400140U, 0x028004U, 0x0C2000U, 0x028002U, 0x028001U, 0x028000U, + 0x201002U, 0x408008U, 0x201000U, 0x201001U, 0x100030U, 0x014200U, 0x201004U, 0x022400U, 0x408001U, 0x408000U, + 0x201008U, 0x408002U, 0x020140U, 0x408004U, 0x044080U, 0x080820U, 0x100024U, 0x082100U, 0x201010U, 0x010880U, + 0x100020U, 0x100021U, 0x100022U, 0x440040U, 0x040A00U, 0x408010U, 0x080440U, 0x124000U, 0x100028U, 0x200480U, + 0x01A000U, 0x001300U, 0x100014U, 0x060080U, 0x201020U, 0x004140U, 0x100010U, 0x100011U, 0x100012U, 0x080808U, + 0x006400U, 0x408020U, 0x030200U, 0x080804U, 0x100018U, 0x080802U, 0x080801U, 0x080800U, 0x100004U, 0x100005U, + 0x100006U, 0x008600U, 0x100000U, 0x100001U, 0x100002U, 0x100003U, 0x10000CU, 0x011040U, 0x400180U, 0x242000U, + 0x100008U, 0x100009U, 0x10000AU, 0x080810U, 0x052000U, 0x100C00U, 0x201040U, 0x004120U, 0x020108U, 0x081080U, + 0x008A00U, 0x440010U, 0x020104U, 0x408040U, 0x080410U, 0x002280U, 0x020100U, 0x020101U, 0x020102U, 0x310000U, + 0x00C080U, 0x220200U, 0x080408U, 0x440004U, 0x100060U, 0x440002U, 0x440001U, 0x440000U, 0x080402U, 0x011020U, + 0x080400U, 0x080401U, 0x020110U, 0x006800U, 0x080404U, 0x440008U, 0x480200U, 0x004102U, 0x004101U, 0x004100U, + 0x100050U, 0x20A000U, 0x010480U, 0x004104U, 0x200880U, 0x011010U, 0x148000U, 0x004108U, 0x020120U, 0x040600U, + 0x403000U, 0x080840U, 0x100044U, 0x011008U, 0x022800U, 0x004110U, 0x100040U, 0x100041U, 0x100042U, 0x440020U, + 0x011001U, 0x011000U, 0x080420U, 0x011002U, 0x100048U, 0x011004U, 0x204200U, 0x028080U}; + +#define X22 0x00400000 /* vector representation of X^{22} */ +#define X11 0x00000800 /* vector representation of X^{11} */ +#define MASK12 0xfffff800 /* auxiliary vector for testing */ +#define GENPOL 0x00000c75 /* generator polinomial, g(x) */ + +static unsigned int get_syndrome_23127(unsigned int pattern) +/* + * Compute the syndrome corresponding to the given pattern, i.e., the + * remainder after dividing the pattern (when considering it as the vector + * representation of a polynomial) by the generator polynomial, GENPOL. + * In the program this pattern has several meanings: (1) pattern = infomation + * bits, when constructing the encoding table; (2) pattern = error pattern, + * when constructing the decoding table; and (3) pattern = received vector, to + * obtain its syndrome in decoding. + */ +{ + unsigned int aux = X22; + + if (pattern >= X11) { + while (pattern & MASK12) { + while (!(aux & pattern)) + aux = aux >> 1; + + pattern ^= (aux / X11) * GENPOL; + } + } + + return pattern; +} + +unsigned int CGolay24128::encode23127(unsigned int data) +{ + return ENCODING_TABLE_23127[data]; +} + +unsigned int CGolay24128::encode24128(unsigned int data) +{ + return ENCODING_TABLE_24128[data]; +} + +unsigned int CGolay24128::decode23127(unsigned int code) +{ + unsigned int syndrome = ::get_syndrome_23127(code); + unsigned int error_pattern = DECODING_TABLE_23127[syndrome]; + + code ^= error_pattern; + + return code >> 11; +} + +unsigned int CGolay24128::decode24128(unsigned int code) +{ + return decode23127(code >> 1); +} diff --git a/Golay24128.h b/Golay24128.h new file mode 100644 index 0000000..9630e50 --- /dev/null +++ b/Golay24128.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2010,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef Golay24128_H +#define Golay24128_H + +class CGolay24128 { +public: + static unsigned int encode23127(unsigned int data); + static unsigned int encode24128(unsigned int data); + + static unsigned int decode23127(unsigned int code); + static unsigned int decode24128(unsigned int code); +}; + +#endif diff --git a/Hamming.cpp b/Hamming.cpp new file mode 100644 index 0000000..d291086 --- /dev/null +++ b/Hamming.cpp @@ -0,0 +1,228 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "Hamming.h" + +// Hamming (15,11,3) check a boolean data array +bool CHamming::decode15113(bool* d) +{ + // Calculate the checksum this row should have + bool c0 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[5] ^ d[7] ^ d[8]; + bool c1 = d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[6] ^ d[8] ^ d[9]; + bool c2 = d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[7] ^ d[9] ^ d[10]; + bool c3 = d[0] ^ d[1] ^ d[2] ^ d[4] ^ d[6] ^ d[7] ^ d[10]; + + unsigned char n = 0x00U; + n |= (c0 != d[11]) ? 0x01U : 0x00U; + n |= (c1 != d[12]) ? 0x02U : 0x00U; + n |= (c2 != d[13]) ? 0x04U : 0x00U; + n |= (c3 != d[14]) ? 0x08U : 0x00U; + + switch (n) { + // Parity bit errors + case 0x01U: d[11] = !d[11]; return true; + case 0x02U: d[12] = !d[12]; return true; + case 0x04U: d[13] = !d[13]; return true; + case 0x08U: d[14] = !d[14]; return true; + + // Data bit errors + case 0x09U: d[0] = !d[0]; return true; + case 0x0BU: d[1] = !d[1]; return true; + case 0x0FU: d[2] = !d[2]; return true; + case 0x07U: d[3] = !d[3]; return true; + case 0x0EU: d[4] = !d[4]; return true; + case 0x05U: d[5] = !d[5]; return true; + case 0x0AU: d[6] = !d[6]; return true; + case 0x0DU: d[7] = !d[7]; return true; + case 0x03U: d[8] = !d[8]; return true; + case 0x06U: d[9] = !d[9]; return true; + case 0x0CU: d[10] = !d[10]; return true; + + // No bit errors + default: return false; + } +} + +void CHamming::encode15113(bool* d) +{ + // Calculate the checksum this row should have + d[11] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[5] ^ d[7] ^ d[8]; + d[12] = d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[6] ^ d[8] ^ d[9]; + d[13] = d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[7] ^ d[9] ^ d[10]; + d[14] = d[0] ^ d[1] ^ d[2] ^ d[4] ^ d[6] ^ d[7] ^ d[10]; +} + +// Hamming (13,9,3) check a boolean data array +bool CHamming::decode1393(bool* d) +{ + // Calculate the checksum this column should have + bool c0 = d[0] ^ d[1] ^ d[3] ^ d[5] ^ d[6]; + bool c1 = d[0] ^ d[1] ^ d[2] ^ d[4] ^ d[6] ^ d[7]; + bool c2 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[5] ^ d[7] ^ d[8]; + bool c3 = d[0] ^ d[2] ^ d[4] ^ d[5] ^ d[8]; + + unsigned char n = 0x00U; + n |= (c0 != d[9]) ? 0x01U : 0x00U; + n |= (c1 != d[10]) ? 0x02U : 0x00U; + n |= (c2 != d[11]) ? 0x04U : 0x00U; + n |= (c3 != d[12]) ? 0x08U : 0x00U; + + switch (n) { + // Parity bit errors + case 0x01U: d[9] = !d[9]; return true; + case 0x02U: d[10] = !d[10]; return true; + case 0x04U: d[11] = !d[11]; return true; + case 0x08U: d[12] = !d[12]; return true; + + // Data bit erros + case 0x0FU: d[0] = !d[0]; return true; + case 0x07U: d[1] = !d[1]; return true; + case 0x0EU: d[2] = !d[2]; return true; + case 0x05U: d[3] = !d[3]; return true; + case 0x0AU: d[4] = !d[4]; return true; + case 0x0DU: d[5] = !d[5]; return true; + case 0x03U: d[6] = !d[6]; return true; + case 0x06U: d[7] = !d[7]; return true; + case 0x0CU: d[8] = !d[8]; return true; + + // No bit errors + default: return false; + } +} + +void CHamming::encode1393(bool* d) +{ + // Calculate the checksum this column should have + d[9] = d[0] ^ d[1] ^ d[3] ^ d[5] ^ d[6]; + d[10] = d[0] ^ d[1] ^ d[2] ^ d[4] ^ d[6] ^ d[7]; + d[11] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[5] ^ d[7] ^ d[8]; + d[12] = d[0] ^ d[2] ^ d[4] ^ d[5] ^ d[8]; +} + +// A Hamming (16,11,4) Check +bool CHamming::decode16114(bool* d) +{ + // Calculate the checksum this column should have + bool c0 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[5] ^ d[7] ^ d[8]; + bool c1 = d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[6] ^ d[8] ^ d[9]; + bool c2 = d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[7] ^ d[9] ^ d[10]; + bool c3 = d[0] ^ d[1] ^ d[2] ^ d[4] ^ d[6] ^ d[7] ^ d[10]; + bool c4 = d[0] ^ d[2] ^ d[5] ^ d[6] ^ d[8] ^ d[9] ^ d[10]; + + // Compare these with the actual bits + unsigned char n = 0x00U; + n |= (c0 != d[11]) ? 0x01U : 0x00U; + n |= (c1 != d[12]) ? 0x02U : 0x00U; + n |= (c2 != d[13]) ? 0x04U : 0x00U; + n |= (c3 != d[14]) ? 0x08U : 0x00U; + n |= (c4 != d[15]) ? 0x10U : 0x00U; + + switch (n) { + // Parity bit errors + case 0x01U: d[11] = !d[11]; return true; + case 0x02U: d[12] = !d[12]; return true; + case 0x04U: d[13] = !d[13]; return true; + case 0x08U: d[14] = !d[14]; return true; + case 0x10U: d[15] = !d[15]; return true; + + // Data bit errors + case 0x19U: d[0] = !d[0]; return true; + case 0x0BU: d[1] = !d[1]; return true; + case 0x1FU: d[2] = !d[2]; return true; + case 0x07U: d[3] = !d[3]; return true; + case 0x0EU: d[4] = !d[4]; return true; + case 0x15U: d[5] = !d[5]; return true; + case 0x1AU: d[6] = !d[6]; return true; + case 0x0DU: d[7] = !d[7]; return true; + case 0x13U: d[8] = !d[8]; return true; + case 0x16U: d[9] = !d[9]; return true; + case 0x1CU: d[10] = !d[10]; return true; + + // No bit errors + case 0x00U: return true; + + // Unrecoverable errors + default: return false; + } +} + +void CHamming::encode16114(bool* d) +{ + d[11] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[5] ^ d[7] ^ d[8]; + d[12] = d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[6] ^ d[8] ^ d[9]; + d[13] = d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[7] ^ d[9] ^ d[10]; + d[14] = d[0] ^ d[1] ^ d[2] ^ d[4] ^ d[6] ^ d[7] ^ d[10]; + d[15] = d[0] ^ d[2] ^ d[5] ^ d[6] ^ d[8] ^ d[9] ^ d[10]; +} + +// A Hamming (17,12,3) Check +bool CHamming::decode17123(bool* d) +{ + // Calculate the checksum this column should have + bool c0 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[6] ^ d[7] ^ d[9]; + bool c1 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[7] ^ d[8] ^ d[10]; + bool c2 = d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[8] ^ d[9] ^ d[11]; + bool c3 = d[0] ^ d[1] ^ d[4] ^ d[5] ^ d[7] ^ d[10]; + bool c4 = d[0] ^ d[1] ^ d[2] ^ d[5] ^ d[6] ^ d[8] ^ d[11]; + + // Compare these with the actual bits + unsigned char n = 0x00U; + n |= (c0 != d[12]) ? 0x01U : 0x00U; + n |= (c1 != d[13]) ? 0x02U : 0x00U; + n |= (c2 != d[14]) ? 0x04U : 0x00U; + n |= (c3 != d[15]) ? 0x08U : 0x00U; + n |= (c4 != d[16]) ? 0x10U : 0x00U; + + switch (n) { + // Parity bit errors + case 0x01U: d[12] = !d[12]; return true; + case 0x02U: d[13] = !d[13]; return true; + case 0x04U: d[14] = !d[14]; return true; + case 0x08U: d[15] = !d[15]; return true; + case 0x10U: d[16] = !d[16]; return true; + + // Data bit errors + case 0x1BU: d[0] = !d[0]; return true; + case 0x1FU: d[1] = !d[1]; return true; + case 0x17U: d[2] = !d[2]; return true; + case 0x07U: d[3] = !d[3]; return true; + case 0x0EU: d[4] = !d[4]; return true; + case 0x1CU: d[5] = !d[5]; return true; + case 0x11U: d[6] = !d[6]; return true; + case 0x0BU: d[7] = !d[7]; return true; + case 0x16U: d[8] = !d[8]; return true; + case 0x05U: d[9] = !d[9]; return true; + case 0x0AU: d[10] = !d[10]; return true; + case 0x14U: d[11] = !d[11]; return true; + + // No bit errors + case 0x00U: return true; + + // Unrecoverable errors + default: return false; + } +} + +void CHamming::encode17123(bool* d) +{ + d[12] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[6] ^ d[7] ^ d[9]; + d[13] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[7] ^ d[8] ^ d[10]; + d[14] = d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[8] ^ d[9] ^ d[11]; + d[15] = d[0] ^ d[1] ^ d[4] ^ d[5] ^ d[7] ^ d[10]; + d[16] = d[0] ^ d[1] ^ d[2] ^ d[5] ^ d[6] ^ d[8] ^ d[11]; +} diff --git a/Hamming.h b/Hamming.h new file mode 100644 index 0000000..db0cad5 --- /dev/null +++ b/Hamming.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef Hamming_H +#define Hamming_H + +class CHamming { +public: + static void encode15113(bool* d); + static bool decode15113(bool* d); + + static void encode1393(bool* d); + static bool decode1393(bool* d); + + static void encode16114(bool* d); + static bool decode16114(bool* d); + + static void encode17123(bool* d); + static bool decode17123(bool* d); +}; + +#endif diff --git a/HomebrewDMRIPSC.cpp b/HomebrewDMRIPSC.cpp new file mode 100644 index 0000000..7e8a2a6 --- /dev/null +++ b/HomebrewDMRIPSC.cpp @@ -0,0 +1,418 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "HomebrewDMRIPSC.h" +#include "StopWatch.h" +#include "SHA256.h" +#include "Utils.h" +#include "Log.h" + +#include + +const unsigned int BUFFER_LENGTH = 500U; + +const unsigned int HOMEBREW_DATA_PACKET_LENGTH = 53U; + + +CHomebrewDMRIPSC::CHomebrewDMRIPSC(const std::string& address, unsigned int port, unsigned int id, const std::string& password, const char* software, const char* version, bool debug) : +m_address(), +m_port(port), +m_id(NULL), +m_password(password), +m_debug(debug), +m_software(software), +m_version(version), +m_socket(), +m_status(DISCONNECTED), +m_retryTimer(1000U, 10U), +m_timeoutTimer(1000U, 600U), +m_pingTimer(1000U, 5U), +m_buffer(NULL), +m_salt(NULL), +m_streamId(NULL), +m_rxData(1000U), +m_callsign(), +m_rxFrequency(0U), +m_txFrequency(0U), +m_power(0U), +m_colorCode(0U), +m_latitude(0.0F), +m_longitude(0.0F), +m_height(0), +m_location(), +m_description(), +m_url(), +m_beacon(false) +{ + assert(!address.empty()); + assert(port > 0U); + assert(id > 1000U); + assert(!password.empty()); + + m_address = CUDPSocket::lookup(address); + + m_buffer = new unsigned char[BUFFER_LENGTH]; + m_salt = new unsigned char[sizeof(uint32_t)]; + m_id = new uint8_t[4U]; + m_streamId = new uint32_t[2U]; + + m_streamId[0U] = 0x00U; + m_streamId[1U] = 0x00U; + + m_id[0U] = id >> 24; + m_id[1U] = id >> 16; + m_id[2U] = id >> 8; + m_id[3U] = id >> 0; + + CStopWatch stopWatch; + ::srand(stopWatch.start()); +} + +CHomebrewDMRIPSC::~CHomebrewDMRIPSC() +{ + delete[] m_buffer; + delete[] m_salt; + delete[] m_streamId; + delete[] m_id; +} + +void CHomebrewDMRIPSC::setConfig(const std::string& callsign, unsigned int rxFrequency, unsigned int txFrequency, unsigned int power, unsigned int colorCode, float latitude, float longitude, int height, const std::string& location, const std::string& description, const std::string& url) +{ + m_callsign = callsign; + m_rxFrequency = rxFrequency; + m_txFrequency = txFrequency; + m_power = power; + m_colorCode = colorCode; + m_latitude = latitude; + m_longitude = longitude; + m_height = height; + m_location = location; + m_description = description; + m_url = url; +} + +bool CHomebrewDMRIPSC::open() +{ + LogMessage("Opening DMR IPSC"); + + bool ret = m_socket.open(); + if (!ret) + return false; + + ret = writeLogin(); + if (!ret) { + m_socket.close(); + return false; + } + + m_status = WAITING_LOGIN; + m_timeoutTimer.start(); + m_retryTimer.start(); + + return true; +} + +bool CHomebrewDMRIPSC::read(CDMRData& data) +{ + if (m_status != RUNNING) + return false; + + if (m_rxData.isEmpty()) + return false; + + unsigned char length = 0U; + + m_rxData.getData(&length, 1U); + m_rxData.getData(m_buffer, length); + + // Is this a data packet? + if (::memcmp(m_buffer, "DMRD", 4U) != 0) + return false; + + unsigned char seqNo = m_buffer[4U]; + + unsigned int srcId = (m_buffer[5U] << 16) | (m_buffer[6U] << 8) | (m_buffer[7U] << 0); + + unsigned int dstId = (m_buffer[8U] << 16) | (m_buffer[9U] << 8) | (m_buffer[10U] << 0); + + unsigned int slotNo = (m_buffer[15U] & 0x80U) == 0x80U ? 2U : 1U; + + FLCO flco = (m_buffer[15U] & 0x40U) == 0x40U ? FLCO_USER_USER : FLCO_GROUP; + + data.setSeqNo(seqNo); + data.setSlotNo(slotNo); + data.setSrcId(srcId); + data.setDstId(dstId); + data.setFLCO(flco); + + bool dataSync = (m_buffer[15U] & 0x20U) == 0x20U; + bool voiceSync = (m_buffer[15U] & 0x10U) == 0x10U; + + if (dataSync) { + unsigned char dataType = m_buffer[15U] & 0x0FU; + data.setData(m_buffer + 20U); + data.setDataType(dataType); + data.setN(0U); + } else if (voiceSync) { + data.setData(m_buffer + 20U); + data.setDataType(DT_VOICE_SYNC); + data.setN(0U); + } else { + unsigned char n = m_buffer[15U] & 0x0FU; + data.setData(m_buffer + 20U); + data.setDataType(DT_VOICE); + data.setN(n); + } + + return true; +} + +bool CHomebrewDMRIPSC::write(const CDMRData& data) +{ + if (m_status != RUNNING) + return false; + + unsigned char buffer[HOMEBREW_DATA_PACKET_LENGTH]; + ::memset(buffer, 0x00U, HOMEBREW_DATA_PACKET_LENGTH); + + buffer[0U] = 'D'; + buffer[1U] = 'M'; + buffer[2U] = 'R'; + buffer[3U] = 'D'; + + unsigned int srcId = data.getSrcId(); + buffer[5U] = srcId >> 16; + buffer[6U] = srcId >> 8; + buffer[7U] = srcId >> 0; + + unsigned int dstId = data.getDstId(); + buffer[8U] = dstId >> 16; + buffer[9U] = dstId >> 8; + buffer[10U] = dstId >> 0; + + ::memcpy(buffer + 11U, m_id, 4U); + + unsigned int slotNo = data.getSlotNo(); + buffer[15U] = slotNo == 1U ? 0x00U : 0x80U; + + FLCO flco = data.getFLCO(); + buffer[15U] |= flco == FLCO_GROUP ? 0x00U : 0x40U; + + unsigned int slotIndex = slotNo - 1U; + + unsigned char dataType = data.getDataType(); + if (dataType == DT_VOICE_SYNC) { + buffer[15U] |= 0x10U; + } else if (dataType == DT_VOICE) { + buffer[15U] |= data.getN(); + } else { + if ((dataType == DT_VOICE_LC_HEADER || dataType == DT_DATA_HEADER) && data.getSeqNo() == 0U) + m_streamId[slotIndex] = ::rand() + 1U; + + buffer[15U] |= (0x20U | dataType); + } + + buffer[4U] = data.getSeqNo(); + + ::memcpy(buffer + 16U, m_streamId + slotIndex, 4U); + + data.getData(buffer + 20U); + + return write(buffer, HOMEBREW_DATA_PACKET_LENGTH); +} + +void CHomebrewDMRIPSC::close() +{ + LogMessage("Closing DMR IPSC"); + + unsigned char buffer[9U]; + ::memcpy(buffer + 0U, "RPTCL", 5U); + ::memcpy(buffer + 5U, m_id, 4U); + write(buffer, 9U); + + m_socket.close(); +} + +void CHomebrewDMRIPSC::clock(unsigned int ms) +{ + in_addr address; + unsigned int port; + int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, port); + + if (m_debug && length > 0) + CUtils::dump(1U, "IPSC Received", m_buffer, length); + + if (length > 0 && m_address.s_addr == address.s_addr && m_port == port) { + if (::memcmp(m_buffer, "DMRD", 4U) == 0) { + unsigned char len = length; + m_rxData.addData(&len, 1U); + m_rxData.addData(m_buffer, len); + } else if (::memcmp(m_buffer, "MSTNAK", 6U) == 0) { + LogError("Login to the master has failed"); + m_status = DISCONNECTED; // XXX + m_timeoutTimer.stop(); + m_retryTimer.stop(); + } else if (::memcmp(m_buffer, "RPTACK", 6U) == 0) { + switch (m_status) { + case WAITING_LOGIN: + ::memcpy(m_salt, m_buffer + 6U, sizeof(uint32_t)); + writeAuthorisation(); + m_status = WAITING_AUTHORISATION; + m_timeoutTimer.start(); + m_retryTimer.start(); + break; + case WAITING_AUTHORISATION: + writeConfig(); + m_status = WAITING_CONFIG; + m_timeoutTimer.start(); + m_retryTimer.start(); + break; + case WAITING_CONFIG: + LogMessage("Logged into the master succesfully"); + m_status = RUNNING; + m_timeoutTimer.start(); + m_retryTimer.stop(); + m_pingTimer.start(); + break; + default: + break; + } + } else if (::memcmp(m_buffer, "MSTCL", 5U) == 0) { + LogError("Master is closing down"); + m_status = DISCONNECTED; // XXX + m_timeoutTimer.stop(); + m_retryTimer.stop(); + } else if (::memcmp(m_buffer, "MSTPONG", 7U) == 0) { + m_timeoutTimer.start(); + } else if (::memcmp(m_buffer, "RPTSBKN", 7U) == 0) { + m_beacon = true; + } else { + CUtils::dump("Unknown packet from the master", m_buffer, length); + } + } + + if (m_status != RUNNING) { + m_retryTimer.clock(ms); + if (m_retryTimer.isRunning() && m_retryTimer.hasExpired()) { + switch (m_status) { + case WAITING_LOGIN: + writeLogin(); + break; + case WAITING_AUTHORISATION: + writeAuthorisation(); + break; + case WAITING_CONFIG: + writeConfig(); + break; + default: + break; + } + + m_retryTimer.start(); + } + } else { + m_pingTimer.clock(ms); + if (m_pingTimer.isRunning() && m_pingTimer.hasExpired()) { + writePing(); + m_pingTimer.start(); + } + } + + m_timeoutTimer.clock(ms); + if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) { + LogError("Connection to the master has timed out"); + m_status = DISCONNECTED; + m_timeoutTimer.stop(); + m_retryTimer.stop(); + } +} + +bool CHomebrewDMRIPSC::writeLogin() +{ + unsigned char buffer[8U]; + + ::memcpy(buffer + 0U, "RPTL", 4U); + ::memcpy(buffer + 4U, m_id, 4U); + + return write(buffer, 8U); +} + +bool CHomebrewDMRIPSC::writeAuthorisation() +{ + unsigned int size = m_password.size(); + + unsigned char* in = new unsigned char[size + sizeof(uint32_t)]; + ::memcpy(in, m_salt, sizeof(uint32_t)); + for (unsigned int i = 0U; i < size; i++) + in[i + sizeof(uint32_t)] = m_password.at(i); + + unsigned char out[40U]; + ::memcpy(out + 0U, "RPTK", 4U); + ::memcpy(out + 4U, m_id, 4U); + + CSHA256 sha256; + sha256.buffer(in, size + sizeof(uint32_t), out + 8U); + + delete[] in; + + return write(out, 40U); +} + +bool CHomebrewDMRIPSC::writeConfig() +{ + char buffer[400U]; + + ::memcpy(buffer + 0U, "RPTC", 4U); + ::memcpy(buffer + 4U, m_id, 4U); + + ::sprintf(buffer + 8U, "%-8.8s%09u%09u%02u%02u%-08f%-09f%03d%-20.20s%-20.20s%-124.124s%-40.40s%-40.40s", m_callsign.c_str(), + m_rxFrequency, m_txFrequency, m_power, m_colorCode, m_latitude, m_longitude, m_height, m_location.c_str(), + m_description.c_str(), m_url.c_str(), m_software, m_version); + + return write((unsigned char*)buffer, 302U); +} + +bool CHomebrewDMRIPSC::writePing() +{ + unsigned char buffer[11U]; + + ::memcpy(buffer + 0U, "RPTPING", 7U); + ::memcpy(buffer + 7U, m_id, 4U); + + return write(buffer, 11U); +} + +bool CHomebrewDMRIPSC::wantsBeacon() +{ + bool beacon = m_beacon; + + m_beacon = false; + + return beacon; +} + +bool CHomebrewDMRIPSC::write(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + if (m_debug) + CUtils::dump(1U, "IPSC Transmitted", data, length); + + return m_socket.write(data, length, m_address, m_port); +} diff --git a/HomebrewDMRIPSC.h b/HomebrewDMRIPSC.h new file mode 100644 index 0000000..85aa0e1 --- /dev/null +++ b/HomebrewDMRIPSC.h @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(HOMEBREWDMRIPSC_H) +#define HOMEBREWDMRIPSC_H + +#include "UDPSocket.h" +#include "Timer.h" +#include "RingBuffer.h" +#include "DMRData.h" + +#include + +#if defined(_WIN32) || defined(_WIN64) +typedef unsigned int uint32_t; +typedef unsigned short uint16_t; +typedef unsigned char uint8_t; +#else +#include +#endif + +class CHomebrewDMRIPSC +{ +public: + CHomebrewDMRIPSC(const std::string& address, unsigned int port, unsigned int id, const std::string& password, const char* software, const char* version, bool debug); + ~CHomebrewDMRIPSC(); + + void setConfig(const std::string& callsign, unsigned int rxFrequency, unsigned int txFrequency, unsigned int power, unsigned int colorCode, float latitude, float longitude, int height, const std::string& location, const std::string& description, const std::string& url); + + bool open(); + + bool read(CDMRData& data); + + bool write(const CDMRData& data); + + bool wantsBeacon(); + + void clock(unsigned int ms); + + void close(); + +private: + in_addr m_address; + unsigned int m_port; + uint8_t* m_id; + std::string m_password; + bool m_debug; + const char* m_software; + const char* m_version; + CUDPSocket m_socket; + + enum STATUS { + DISCONNECTED, + WAITING_LOGIN, + WAITING_AUTHORISATION, + WAITING_CONFIG, + RUNNING + }; + + STATUS m_status; + CTimer m_retryTimer; + CTimer m_timeoutTimer; + CTimer m_pingTimer; + unsigned char* m_buffer; + unsigned char* m_salt; + uint32_t* m_streamId; + + CRingBuffer m_rxData; + + std::string m_callsign; + unsigned int m_rxFrequency; + unsigned int m_txFrequency; + unsigned int m_power; + unsigned int m_colorCode; + float m_latitude; + float m_longitude; + int m_height; + std::string m_location; + std::string m_description; + std::string m_url; + + bool m_beacon; + + bool writeLogin(); + bool writeAuthorisation(); + bool writeConfig(); + bool writePing(); + + bool write(const unsigned char* data, unsigned int length); +}; + +#endif diff --git a/Images/ALL.bmp b/Images/ALL.bmp new file mode 100644 index 0000000000000000000000000000000000000000..eb3f4fdf4b31d28b77aa101637c881e49f46cc06 GIT binary patch literal 461130 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€p( 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

6Da2 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 QR$4J>{pLy6Z*gGW; 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%0D}1HN(5o9-GHfHog=W)Ut7)&z{9w2FVVmXA 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�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 z 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 Siuk1_o}*@=#72^)vHu6dGNnQQ literal 0 HcmV?d00001 diff --git a/Images/DStar.bmp b/Images/DStar.bmp new file mode 100644 index 0000000000000000000000000000000000000000..abb23f666fbd802fea4421dd7707483df6dccbd2 GIT binary patch literal 895254 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%0Ag`V|(4HW4LT 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

a5a_A%V+~>4Am;^roo)P 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 literal 0 HcmV?d00001 diff --git a/Images/DStar_sm.bmp b/Images/DStar_sm.bmp new file mode 100644 index 0000000000000000000000000000000000000000..cfe79f5c77960c755e10ad594718813670bce675 GIT binary patch literal 35574 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 Y=o6auvOHUx5y%K+1Tq2{fqDr17f&6nv;Y7A literal 0 HcmV?d00001 diff --git a/Images/MMDVM.bmp b/Images/MMDVM.bmp new file mode 100644 index 0000000000000000000000000000000000000000..5f740afbbb1b79a1a9aae52d86cff3a3f477306b GIT binary patch literal 104686 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 z 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

6?DJ9&i1&Y)$Oy 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 literal 0 HcmV?d00001 diff --git a/Images/MMDVM_sm.bmp b/Images/MMDVM_sm.bmp new file mode 100644 index 0000000000000000000000000000000000000000..213ac282d334045da8d50888cd5e761728247c1f GIT binary patch literal 14454 zcmbVz1zeU%*Z15sA|Zm3A}Ar<-AE%KVxiJ1ii%1|TG)uFh$7wHjVN|^x2~(}x~q~( z!~Oj)F1;UD_kG^q`^{d?&YU?@=gc{C&Y2tQIT40rJn17>!oM8+n}&Z3B8Hq0%Wv)D zm2VmIr!>YK8)Y)T=P3O9_fs!a|0m4Y1oH6&I=VgB^}e^Fy}baZTNY-EJm%ufk$ zx)p{0Yx>s#|1mym@&ADSP@zciOZr#fFIfL8V3bMm^gn3hMeq*H8&AXF0mT5C4QL(z zhA9qzgQC5U8iEGU-Nwr_^0&b;%OEupRR#O;Q9K+^-|(n1&ic1`F#?72y-H(#NB^Pr zt%x!Hd-{$5_WgIn|5GbY#s7-`^-EuG&zJ75?(VLhpT3^%?~v|a(m#>^gZWSRPXqp3 z?dks9(}|gTJHPgH_IG#nf9~%4@CkGEclP%D@u}n8$F7dAU7x#qK6Va#?(OdF>FMq2 z@9ydS+S5DK+co^<@7_HXv5-yMH{?fJXoYtQG-j;_9rFTGfQNB^gf zoqv4%^RMo{<9+ud}DOqr2yG_m@vy{U87CeBb&0-KY0mokN`+{hxb2_H}>3;Jv*) zUA;XZ%a^XNzfz{B=NmP8Sf%f~{*?|a2#~*i{ra!$=GlQ2w#{9ZdZn z@S!1`!2hHlPY%uZj*gDYmoB$7x7JkGmX}pjR#f3bp`yI9thAiYQKg$u{q~hn1prHn z%c`qtfXV7em+6kBC1q8W)yU})=q@M&NcAnjxRsUVRh4D6HKmocfRt5am(?Dxtjn!z zEY5E!uFK7>s>v;CD{sguDR0Qmy_i>CRZ&?8{GytQ;~|n)0IJ698gE`GsezN~%lBTQW-8(u!IOi|cF4YHEuc z3du}1<{Kt@Kc3p(lY$~0#m1mO`a?wEj>*{M06q_KL(jHWh$Bk1%xn>u<&FF zaR~{DY15<>-JYj~+ObJO@NkLw<>B3Wm_$6h< zq$Ue0PZpBpohT_fNnB1!Mn+arLQ+&@iny2rHjYh!J~RZIqNyY!Go5e3#7UEcCB!5_ zNwKNo6L|SRAJ7V9L0>6JX>oCJVPRqHSyomSyt{t=`o)VEmn~bCl9D2W{?n&}he=6E zK|w*l(bUvbQc_y5U;!AUp`jr!FE1)8I(hPBH#fIw)20C#gD5B{Ah)!%eDmfF*!m-X zA5w$m$DtU^^sOK;`M)igXa zBa4lV9p$XdY~-ArTxrMC>89MAyw;XhECkirHntbeU#PCE0X0xv9=PJl^|=L=ktS3 zr1{N~phkLo>9D$-C<;XfeOj_t?uqn4Iby|}s)GS-S(~EQc%#Z7)JP5vj-HlEr5rhm0@BC7KXG&Opz!$dlb!LqcJA2q^2IAu-CW&^3X9d%HO`$q zkLvo64H03RA|s=A?%aiHLw(~M7gvZK%Ixf1gpC_qKb7T{6QbR)+deVC0q`f+mYFDu zEVI^WFVt^I^7`|X4|o^hYt?kbPLMDrvU6U@a0zy@!h&|inmuaNe_u6Y+Xh_;!kd4@ zBw?eN@&qwXJ}zp#0)&I`)oio7T%^9lSOFuSDO#Dma^~d&#xW~RQSCmxURjFISV!S@ zmVcO~NLo@jfIEVX&*eH~gxjc!ff|#@_!;)~_1(OA^ZWPjqoSgMgQ*h^?TQ>SXkb7& zFu10XcXf7iaB%YS@I8O_0%8kI1z_@_Y37EfaVrG6)+RgME^a za7|4On8nh}DBwbe4mUC~0)BRO&gjT!dRhkHe0&oD`Sj@%a$FP0ksd#Oj2uHDcXD#x zyLTT2CFJkFK60=_0LkM=kI$Yx|MJD_dw1`lx+x+uEHn%{;qD!(ign@uo0*y)Oge~a zW_lJ5c2s0E%AA~n3=TmIai(y7V2P_m^FbFhJ6Y;ZVkhY#x>pY> z*Cg7h%JA_J4mJi94Ds-o3;KkIha-nl1q2r#@~o^Z$RG+GpDA&8_}~!~H3~z6!$(t& zLGPlxeOo+w?cBK&xum2dAfch5=ol9p_u0a&T~Y&YKU`UpRk}mlx;#oBV?N#l^+H|Nc7$XQjcxLFfllQ|b(tm6Y$= zxf=zv;-W<1^XJdVq1BNiJ$v??E-1(=K70BcVrx6w4v^QcexuK4XGiDE88hu{?ccnn zx&Vk{46W|tO{u%ptApSC_WNHS{?gFUL=~ca_RKk~9AyR@7uQ4vf#Dh_+C|emmT-N(m)CR_7IP%JW506=f*uKQ$OG6?J-{$)yugnE*zzJ zJ$1r_#&Yi!bEXLpe!>IQ&(BBL)-QHCUAt!89HIWJ>w$AL-sMi=vX>3PuI3b-d!9z? z&6p_3Pwq7a+^q?`+MEnvMwrX*MRV&8+pP(t^e|1yrAwE-dP!-gzyA7b`HJNz96EHU zt*s4&rBI;mIy#%1T5jFEg)%1x*YMCtPIk`11&dHkI&iSCpb!O6SWHX|g)N)6WM^mZ z+nca=&%SM2x8r69(GDFv4E{nik`Es_*>)0WXhIHkha5Lr!oK}piBu;iN=o}GYQ2_z! zzNYU}6zCI6A#iXp#!ov`#}v`2fFNPzEKP+fu4&jIusX&YsZ)p>*TzEHR9i+xMPwYv zm}jEI$H~SZ9I7&$j>fYDA%uj;ii_y$O9S0NMcz?&nw6f6l!yQuVW>`%lb53AVh}E4 z9a$J~oJ5G=fb&wl)MbokO3U-J5f@!mZte*Jgg6>Zu~6Y3-x8aNsTvy(<`+<$%I#z! zD#42_^Q%aRxoAq;n#`OjE5QK;k7LNj4wXB;Hq1haGo4@veJ>K2lrXDMWoJhh0y9!n zbP95maf_iBKGq<+ckRi~D*)fk%*+i9jpljGgR8wNXtk2!ENN+(%*-qZzOj*s@+_58 zCr@3wdL4r}JGt=kU{{nP1)XJO0~85!w0&lAVP-EFSx z95;*~6BUb#GA=G|%Xr$peLF6l=;#=zQ?x=qIM_QmIyk#H&%s4Z;YY`Aj@zg|*vPn5!JFqUbauD4b+mOevv;?jz1VB%Do;nh02@PR z4NDgtGglKs7b`TY?X0W~92^Xc94urUO?4L7nl4%3>OOalyNipJ zrM;<*hrPWMHsZa^CvsC%Y)ouy%w}lX`1ts3+qQv75fKs5(b4{X0U#sx?&#p;F?Sx2 z!$QMjW8%<-rq4VNPY?|s=-}(^dn7ppCMcAxj`JVGP$89bt zE`@nkRaFh6YxnLwnwnZ@($dt{*3wxOvd<$-2amfBjTMyA?Ynwo2Z*YDh&R8U&p*4R{1S+PAK#Xl%OOG8^%+dxa-P*>N) zH)z%F=#YX?{fcnS@{PJhVY=Bd>KV~$d7JbqH)vLGG$`JnUARf3G)$*@gKpV2z0`GT zhXQ5OBjpdrIPQrJ%Q})-Q+lSp;Y?{!ZSsyI2^*K^h3XeYYvo4jW<(jKMQImo(W(no z*&FHMx@4iBZ?K-azOsgfv9XDnsYU$uow+&r4GqnwPM$t<<}^qI1=!fw2r?c!b}VGw zdJA(4Jw1KwR9j1X-MWyiTeiXHZE9?WrwloT1){E|X`pYUqoZeIZF~68k-QvAesMFx zzrguXRZ)Y9h1(Xrz+xN>IoTPoui$20zH|lGB6zByPF--y$|{Q&d*J}USi)ro^9CN) zul&7x_b!g#lqpltg-*)K%BiWTw{G3~?YG}>1;gHkRrdPz>pOSu96x>>r}R7GxBo-5 z5xlr@;|A>W!otE`yQy1}l{`H?=ggU-rl!V%%$P9)ZaWN4Ox@nzzHi??;ILXzm^Mv1 zD=V|Dz3ukByBDur-L`wD$0F+fVx@>JYqqSOlfR7ZL=ZXeN6z|^dSBA&OD-%WjY~*F z0I44Tn*2%AQc~$jTK!0i52;$lmb!?v?9eSd7T4Bz_w2RSYuC>nj!P)mY*e?HG%X{i zS2CIdNbOQ`GKe(#ljB|jJJz}QES&f4ej1-XBqZe6v7-+j+=uZA>jerB`OB9tFI~En zn3%X^$r9EgQNT_U_9nEpoPdQ1?Rxl7@}fnHSqQlJaCfJrr6uk^07-`(1=S5s!9N9y zVGlzVW+^G7`=f`C5I|VBHU!owq6gsh>Gm@?0Jyb%ef=Q#h%H!JSi$Z3mA^2d4<0;- zWz+N0{uDG1?5?h^F4j#AG;kcOq^(36nS+D6V&H(ogS&b2=Cfzd5Kh^>n=;an*x0BW zYT?3#9v&WgdV1q9Dw{QH7A$#~AezvHmzOe)!@|M}3iF>oe|G=={liC& zEMB^lYNf7d>LQHY5}p|9Rlc0<#71%^kX#RDoLNmy29m2m@+ zA3_?}l3OcC-Db0S3vKjNmH9Y$IJvm6Uqlt4263seD1!pde?vnMhaxQS^vSaa_a7oy=Q(cyn&^a`LUY2tf!z`=LOyR597in1!MOW;%I=kVd5_)Et+uv#zc%)~#F7isd27gM=+(0T^0bOspV3@BEq5ckkSRyaf3A!@LpXnKY4y zSAb(ebad4Ibsnc9xNk(0+ri`}xEv)?96YrlYHDkkU{jbtV}xKsm{83+uBz4SM;DRm zW#m~Tc^5?!&?UnmF&?y#s9_yl}=4qo7CwY%VTTr_0DB zB^^LC^5(6Z2r4cbS43#XPzXaEIB)>|FF3ezMG%ZA+-}g%ii%2@g-%9>#<*%voov5# z^ESMdi11Cg*3m>;cQE6A2F$ltF z(D@h;{B?JCx3aRLfkHw;hK7bXDp#*wh1BobwMziwAPEUgftC>#77-T4_`KX)Vd0@A z#l@E|T}n$$U9~cZpNC&!l9cGANn(PcQJZ29ZkT&Bp7YIC@>>J}m+N=VN{pPFa>yq$ zV^dZ}bo%kA^t8y_?AYAws1rpI7Y=xwkLG&6m%NGMe72d~PSZM^9CPT%@#;N6CwH>H z+0OCj4)zb**<0iJ!UAGw>C?O_>jezoSa#N2{_Z>tP;Stc5jxkD0OYhmU zCnq;2F(DDw7lH;24UNEuU`k3#fse;i)2?2<1_(k%@IE*>D765K1*Q>19%aZotXaqn z%J6?nN=kq7k8u3x*M}=tu0T&BkcE(@oSdAjtgL~70d7f%B>ZBhm}u5)&7XjEX{B0>T3OFDPfIP%Ho(2N&+#z6~33-P*NYix(>^Dk{q>XsD=~7#N0zte@xZjzwx} zXeiH`WoBx6JT(((YFCGFX@J31;_UQS+1O;cG_Nn@6FbkvrE z8|~ib@C>FCW)}PJnWX)=No(n;hrf3X_xDj^g~wIAhz^bZ{rBJXS6}4p+H*Hs>r*Zn z%;Fr#CNGXn+T`m}kl^?_g?BKGZ{Qf|%VxipEl{2wTU1}3w(mfDf%T^&WGIg?a~Xdf zAy3P+9cNoEUg{^Wq@t{*sHLK&rJ;NvIk~MBme0cqsH{DEX3m&_jo^qX$j$ItxCk53 zP*v5|&;$`6F5%%}2?_hMvod{rmd#R{1v+5ky1Kdv`vA;>K?VMTiSPe-5BqB740)(u z7*ud45#q42v_=yIeEs^3@O!iX2BY9%K{LbdLP!J;Pe1XO)-cEs=s-{u zx3G(g3rG&()zQ|5G-alzpK5DMOi0)jAFr#et*4`7X>JbU$3{nkW#OTrn(FEXy1E8> zdTJ^vJGO6+j*Q$K8*6H8Y-C_ysIQMM8$v={U0jxWc>%}R&`@7jcmBM22M-)rw`NVy z^5q(8Y9@w;XwuWy-hkN|h72lSqSj=OK}w(j2j@{lyMnlLNL zSRLuEpT5FP{CT4;vy=>#a4>7wzUGp9?e>Qb9lv@1&Y8-#jFjbn7Vt8wIL1mDgO!ZV zJkg{`o3IVhDtaoKx*GPn=GyXdFx3kO5&Q3diJTf9;@xp~T24*HEwl+4-j*h!`?gZu>XJ;(l zYMe)#!oyJw^!K+gGXn%f00Nl4ed|`>;Ip>0#F)`BF?dYDEe6va2itTU8LbgvVZPqp zKsGZrwYIP_w=%Q0aEghF%h~QY+|0*pZO|QwLE+ zI16Pu0)~f3L=5l(g(xK^f&Yuc0BsBe$T$MjP|n3g#aUU|@Q?l{`K2HI@eUOe69Zq# z&dv@mjE?s9ixw;ZYao?iqJzD?ojsMH#&dIX;qh%p=q4@>>jd9joSd+1V9s@O^Yril zPw`>PKtLgQ)hZz1v$wTf9uP2Z?p!bq8%z)vH%yE+aCLC8c6WA*i{6^K#fEuZka?3ZACk{k$hmTt{Ylm7*B?B5^5E^e zcduUm_VU$l&z?U$d-dF&vXZT9{6Ab%Vm=}xS2)J*k&~w@8T~yUtIuA|Oj10Q+}@(W3UUukI* zg4Tt;RZ~-kH-vX~+^{gEz;Q&1pq2py8sfUZf%S!0G-CS*9|4H;YkZQWpHYCV1t$o0 z6j*F+V>8#?9mI!fh5iAHQTAH22({LV1ZWrs+6;#oKyVg}2FKAQBQx{Cc!Em^5ymN6IDbA`K^gSLAZ|`> z?#}a^J#6N=&W+u)HG7L4^A7*$W5Rp@9+792qE*{nDziQFGS(Jlh32Pk$UDA1_jpL= zQNNlrop)81{nxme&k6H3W8@YYzRmXa4rA~U8N9(@KII!aDczK}>+ZvA1E2zaZ^dN3 z>i)PpCFMnv^T;y>^Bx&`K>8kXf4XV7+{S!maH!oPhXu>r>@D40oLq2yU{hEsa%=~t zG9>ru)2E09L7I{d9<;Quz{c@G1aPErwrM)h~e(U&ZAECd-*FT`)5e&O4$ zSiTZZ#t2A)_28hQyb@m95%E~CV4nDP<=XrhNj#MZ&q(P6fW zjkBS%yiY#32mTH3Im5vjJdv4g16jDs(Xry|HN7!3$s zXXND-VNuhqtQ@y6%7}czq=zR?vGd;&&0oCf!{deoX=`cWHi5x_9DWmi{(;-X*u(^a zcK^Wx41nMIAV1yS4ujdw))o;A6JukX0oX-28@Oj-O~G)24F>-xFd)D{Umru^szr{n zv5}FrwKc3bSmrRN@nTLd3h!=kh+qcjXlc<`HqL;)p01UtrL~czv89^6nZ>3JJ4(0N zjyCWxo5?^K8?%Wq+C&D*$yftnHh%k1rmFR1tcq={fqkroj8rp5ngC%8*0J|g@i3b> zU|)T#m|RyLbob>;%sw^*)(%m07-PQg>fVvR|7qd;(E>73PcZ&i8T;FM;{}#_At9m0 z7D{fgC5()50&$o zRFsyM4#G%FN#ltb{uf@O_FTV z@7?eXVLD<9TKM0%-KeUp3{P-%P!K|t7!4z6XyRRhN?KYJ7TjJ;0h+-3#%Q=8kWhf; z-w_`VdB+IAgTV<$O9$@@vkcVKW=vPohzj3RvCIB#4hOS<4Cj!MJTh8DU`rz(%OPXA z)Hj;_?HkD^!|;r9NN)z|$tHdIgqcSnFpEjYUh=xkqv=H12!8AQPqGY-F;72x*qFNN zW3t#+cwxr~=6aLDR<^||I%KtyimbM#I(!E#PfJ~$TBo`?R2hQm^fF4X~@8^e0d5M?TvL#D!#lT;H=Y>`*iB1@bE+8g`1A{0%2E^1D5GzC~ zuc!dI7A;%|#qQ(n?dR*`>*F8by)Mw-+sAuVPD*KQ>e@SX=I=^O-W8j?Ei!pmV)jR= z`MXlncV#B;%8bW9x@`KQOz%;)>a}AEk4udIxVrRiiP@(@A zsU3kMKT-xiiyt29tE)@8TEFgYx=Ck^=|H2_gIxW$7Y}a@Ulp@CYQYje*f#LlA-2nw zE`^cMP*(>ZgtY~FJMcOYkOvt-L*z&ZVeMMjr%?r*PB;%R_F$)B z7CHoqap(lawtGc$`yv+K%hPuE_))>eD6dRuY&p5nBTG zO1OyevIgSNyTEG^xzP=vjE?7XVeDoVf=pFr%5 zL;jIa?}4#J{b>smf6g-0&HVJGzhhviqj%(E_ovY@SYl(t{oMoo{ooG%VVnQx|4Rjg zqBo9bI8f=w{j&51;CKi?zzseu5*}pVzI}^$1qyiRf#C!os>mUyXaW$wgvZ%HLYS21 z#V<4e3;-HdOEZzaMCio;4pe$EbQx6?XiT~Q2&%xt2NDfK+2R`+0doPTNBeO;^kO9z zoHZ#flELww^ners_17pEcyMfN0OR3riT)+g*#DNpeEPOB=FlMaLM;*e8^vEa{W{X< z_@6#OibqEAr%u=grlS5TX_N_G4uJFY{1}5;5cW7aiq-zQo?kZz2+(LaHjA-og8$l= zM*CMd4Wy_&o@nyYBmWnCx{2;WBh%%d;H+_2tt@2Pbfc+@N$Kg)oz;aN3j3lHswjL% zq{d?{6>wDPR$x#gfRxnXp}^F6p$PT;Lz(_4q$A2-!#Hk)?_u{KzbZa zJ2CiZsPpp3i`FZ z^pwt|RqIt+gHCTW8cb$`(Q2_$RvhlT?Z0;q05oRc(QKl|(PZjL{Atlq1`NN&fd2<4 z@a7(cH)@qeZ^4@}vtrO9o9MZ7F=t2S{?OwG!mGqzYP4#A1-PD20%JzArZ4RPvml9^ znYcZ7@2V>$yR2rl+D55$8ntp1kb87fvNP2|ycCu!G1u%50=GT|Khvr}t4t z*$5D8qk4y5nkc1S*Oa{FUvJg!@9(<&?6%-^!oL75BV*%a7C>yuU*0+|DLBri)J>3@ zFK-L4mG01}hSm6tGC>&Q;Qj5Tdp_~Fd@$IiP<1QxW=ofJ=le%K@_E*Lg@{~CDYFR| zVlW#mMo4@8&HSBD&gD?n3CuDaMXRTj1gDhTWFV8wN*OdbyxvCX$5mRp{KsCK*;C~7+K=SOJ_N~;>v8}HweTuAx2e)D@h&u#*i7ON2uCoJwir!V z1S~qe`W0{{cl+J;E$o5+?09wQWfQW|TcyIPUF*=gE>&aPhbhC50(dZ6DHRa0F>JBA z^On}Cwi!*7Za`y{{PQq%0bX%?8Xv z^~DRN>q*?Qy8l{US<2>@ZA}om8nvD%5RlR;B9zHlfm}+Per$tm^pVx7H+`j7*r0CU zc5oy1hNBswdVJ&dEgZ`4E{TBY72B&iM=77oP2ZJ!Aj0_gq_(9har3A5u2zf>V&0B@v3^81wNWaiR-@5CZ+&*V zq2xsTWNVpbu(h`_?R@rn%B0j0DF}sE1=aVaIHu=jcGvB^3*xQRz)itUj&u#78puo58?+bw?VVEiKm}?Z3nGe=R=$vuC#$?6j1ba0Uhd z3?>{I-)>81nY`&BrM*vSp2J21Xr5y!rba2MqX#Awr5@AugH{+Cevr21=al*qmhVZu zc?|NHGB=+(aldL0WVM3GJw?BUg48QdT03z&3p$2IK2dw%cfFk*zz@!52bIjL}e z(6jT0DeZ$hClk*X9i_DW1Wpj6N}b9~l_vkNwecLKHQW%d$c&wD>1d;RAEd|8VB={m zcK*)>RbsgRnqX(}4>GrZR(_n99Q()f!VT19D-pARu)$)|X^DAAf$QsUy_lAFI1V2H z-b$E((2QiD6>*aTyF!=duYcXr*Dz_I#tfQqIquqMgw+Uh0Jlfx>EsI&rO@Jx`ra{( zjNB&vX|<|JBltgbAsYUnKec+SK{)t#+drrWKvaQGCN!`O3t!dhOd}KckgWc9&Sd2r3`yA)mbQm=t|Eid z14ZE1jB=e3ibq2UtL?!IDDVaAtXs_`xv^jhuc zm<~J$)qYE&=xEe|WUx|$Efp5~x=&OEy-A^hR3y-+blrB^1S$bIWP{15HJD5~lNk(~ zT=BGjLXDq~^|kdqy9scCeCT*o0R%z#V!uKu8}E4_N#2Cjgos(oIHi7`wwEdIzi+b; zLJpLLSwErC;G*HD>Hi{T#lRzQec<=BGL1}z`=eC-O*wmF{sQB)^LEMAI;iZ_}*`#OD@P_ouciTUp z2QU_7GwY06m_O!;fhUJzKBUIa4~~tD5fP+(T(Q0=fddST4fR2^LPpE9nwG1Dl;#@L zkC%@sGk1L0`}_t}WB_GU1$hR@4s|u3wHXxzJCs4Lx9P}$4pZhaD7uqGCxIw48=-vI zS8#|podMSYAlM}#AZpaAHE_oe|HxFsktWSnjg0~;hlW4pI;GVH*c;XG2-+x(!6+Z^ zrSwCXV`Jlx?Kqm|+PR{Eo(DLI(m=l1`Rqn_)n=+Qi|Wrwj`{&L46cu;)A%>02F9<{ z9{AJE$^*KIj-E&7@1D)UIc0J=xk%C#xHHw|T2afDDl%WFvD&0{M>#*fb)gJrBB!$& z6-H=K_^u6mUXG5y1jTQ3dZ;&3y-dFM-S&6w0f3E+l|^qcK!`$sb*FA!MNM3gL-)gO zc>YXJQkcs%{r4t`ifxoBp7l=jmWehdZ~SRyV&u`CAD0Tk&9;}2Oc*?+R%ZoSU-><`jo-r60yoYJ*VAx&;)Jf1cj5OQA6*|~}r{HFu!SLYv&q^K7_yUJj-JMnS6 zp1ea$Ro4~DI$kIKLbC1O_J_RQ`}h*+Kv>6^gG3B#M~1rar<&NhxPEel-{G0`&_86; zz?dQ{BatMa0w|mIW_9Wf$tGaTYMRgxFT;2)_w}~Me5lYEESpwIlu=6Y{EFoA>B_<9 zV1q~PLW%h1F#7PXVG!{ZfD^9#w_l_WSE4HkBDm=S&x~6 z>o;Q7KnceUQr1Z*DrPebw2`5KHk@BMF{#zU`EBlMzfqJBN)6OgmLW>f+jdSM-2O2& zaUW+?=**K4(XclsZZ%{wG#zziS^E!eUaM~vU&xH4v;)LJV>9X0a@-Q7=@2Gt>v`Uc z%a~NDjbx@+bchQ0Zu^Jy0EDhWO;&#liIEJ9rN8;&=2bt|^b@v9shXt5?(PqH(>Qbw zxFgWA+6G6UyaHN!g9%u{8^RCc_gWo5WFex{MvbdYat)SviyALP*#Pzk7lz5BS3~I_ z(8Q}suZ77(4r{Zjl}fY0gr5V(XlgB#4ZJ5lXd=mR5QG#NOdwy-5ZZ(gB8X#?o*ZpL zYXcR6yRaFcJX_Qd^0*`;^je(W3=IGZHlZ+}H6cO@)*zH@J;INyDzz2SN8mQBmf_~> zB?xxX<6D$@9kghiGr5{P{o&s7$*Zy_%yt?z&OR9K+2S~m*Z5JPe2s~ z$l`=#O7w!Ape*3)CiLWVRujxXTo`aqjZdnHo~@rWswV*|BKARNTl7{nu!(sGfk_Bw zKpAuzIsu+d#B>ZOY%g(Sg1&(lw<<>Dknk#md_WzCG9}#qrg@Ir_G0J(V0&1eNnzCu>y_O~*%R4V z^Vsmc-sd;b20BO^>}Wz8=^{-&)TJEhQIEgWDaMT&C6T=Z>3}@04G;y4A&Tu%*#-@q zSY?1Q(XR<#rnf=0hFzwU!T7^cV6~|5I`tF#^%xYBlm>*&)WjlPkLv`?VR8cAfVdW( zn$Lgt{lnWMd)gWSS4w>&cW=0&{~=C*4$&GcW`hPR!;$bet^JpX!HDih!wf?ADRpuS zk<~B`(KRrC$w@&ETJh&MZx##OlvZ5()W>*(Kd}>UzH$5Jqx^T+3p2{5H5n0RLnIpk zwOy7eZ>tAe4QeeJGJ*qxMnwpWSHKyc0ChT}UT!pK5Cw-(fd&kz3nm0>E0knATFIAy zA=0cwyp!dXY*S!>a8pw1E=tu&O+MBSG=ZjTZb&>WT3?n-FWs=9IDTG!lz%SMD=XAB zb+u#Sr?V11o+PjX%At6zQ)!S(S+HyFYFge}T7KB9Vuo`$&$}jW zUfsr}4O?Ds$l7&5a_Cl7#?!{~mk%$i`r5$JP?|BlV%VgS*N)gf8~jE(Gx5liKGd`~U(}4X6Rc927gxnK*}L_V zeYjgJJX6ZdXxDwomn&?e56~+lm=Dk;jw&1IaUh#?JNgH_p-GF&&={;Fvh_dQ09{~s z3dU1k{6;Wi=YM#Zf94M%JoWI9AS@C?09>KVluz$9Y>Qr)y?dqk$s@AEg6Maw=0uBp z6`ngrH1O_0v<^<{hwa20j)f5--Kdesg@Vdt4?Pmjjs?dZNxk`v9j7 zkI%S{8U>3(!OI7r;vVd%!`<4&z?e)c!|fAO7dMGd^(M1Qp_=G@)Y$#xwoylHUZSIs zZ_Bd|@UK-R!TS#}iq3&NvEv!5BQ`ab6{7YN3lZ9#nHa7156FkF-lp*U_2>WN@NA~k z6KVovthOW)SU&jdLduuH9gp%JpE_K-F9L}p_)KoL!ij)&^VR)>L!iMEtg)G~G-Jpo zjIvI<(o04PpF-Jyt72;4tpoRDt!ExJq%~wjBKLcT!sqP|_DcC|de*wRMJ$h+ zIKSHUewER#g^@EvAv8&p6Ivn9xrpOZ%5p7dx>rV$Cg!`L1?g+&pV|0EUF?zyPGCWVk2K6n67EyT2q} zr#$Y0!c9M}-1|XY;=0or%zO2M=hsRVoi`|TFEBi&f8Hv)W;ZeZ+$TO~Vd0y=DCArm)`(b=^bHK;XkikMG<2hfp*2Lts3ST4!H*i<#$1IMMfa{XMam(O(WOBXJx!#!!7Xiy9i|v}j1J1pq(LM!n zK85kVNld3Sp1UyKJ8z@EWV63`gO4!AJu}LwZoN-+j7J&Qxq#`I&u}PYxs-6-%lTf} ztfg7(Wx}X;inqVtm`U%skU;g+QJOmxaeAAqMg#a3IJhB3VWtvN#SGO=2ju}b4;Ygr z$licef_(7gCg=pvS5%bZ#kHzbi;3_p@HW~hYseHb7}zs1Hb$~ta1>Rqc>AxvSTQGO z^Dn7!gmr!M2HV7LrrK<9g<=Z8Da^ilm z_Y;@>D`%xdx(b-IJl@Qbc(;?A{OUFYR`UYN=w1cEt^#^sR^+@K)JOp z6U*}1<+44WI21*DBm{fuTZ_NB_c3?Oa3~SG7BEJ`8~ll#uYfZI&VSDh>@So741>~O z#(V8ZtLQ)o)mKC8H4Kbl#3XM?*!-9F>jlU~vIlE^b3ef3!?-|y20;OK0;6eG4-K{7 zxL&iR{P;?E3=>y+2!q{?Uqe<5`@hV1ktjCY0_|7 z8IxAUqh)Xxp=I$F0na&6^MzdhY_4w(+ozc4T+DSX;J5(W5|*2o<(9)FO%US(QNKUL z2+^xU8Cf+u3yMh|HOKCdo0U8_dFHtUCVVZW;%&E&bfRyQN%(qW1*N$gm5l@o-oQk zgXfbPpzY`TN4FqGpt^XyQ6b#G$O!jI|aY;TP=wl$y9mQLTf` zxyid%T|JXGG1>>c7#SpLWNctWFg!LZ6h-_RB(sXhWDLuwsiW*t+Gi;dzDHI&rqO-G zAwEUyr4rWiq&0y_pL-QY2AtvhUx;!OMmR~iUin;KA>BI{h@J*FsMagT$DR(qZ0YT4dfs~G z>Ak8aH;bO$ls>ze*LJn|SyNfZt;*g9b%U*E#@jE+yRIs`uTRQ5)tZ-xMKW25qaEQ@ z2+kgq0dBy4uk87)zNVsk=7l*Fgt-=nxtE5yAC6g^ zz+aZeeJhv!y#n^Ka;{%ZltWz%Ej^r;PM?+Jg*_;zJZ>3IzUC z#2}%m(VI4%Ts;XojxeQm76p5ujUZlBt%iRG{fP#I;hj zOJd$`FX2H%VL){VJN-s9^tR2ZQ{Mu9}-2>0T5wuOxm^eT>`5SdX$OPe8YTKffquaW2#6#G1Jk(cZ;T z9#A&KOwW`chhv}55wZemcKxUyCd` zyZh&*>lZ_{zQClNWz%YTv{D{T!kd=G^hgh1d?NVG(nz-ohFe3l@9CI;{9vb~KTi{^ z3#i}v%a?aDRUNgIvW>FJ;T_Z&Z3v+q*OFxs%m%_m5RpRMSW`-dMGuK#->}|6jn=`% z18o?Ym9N^Y#-S+%0|cp}_aUMf<5vHm`(7#T1p|arU>-poH^>Lc0m()J1MI+tp9`{` zgyj&(|I=<$cz$@H(qbHkw+=ZMR-M(XFoA>WRY2EJjda|4*?y(x$tB|6!YCjBiOhK9 zXk%F)}kWL;&R@i3hsgm&ioQaU`~)v%BSvoR?t!yK6QsbXsy{VZ#zfH zd+bq#7Lvnj7YlYQ0mNAMNCW(UUI-AdC2&Z=&5sR`el^_m6FRG+2Z6W)um=0u?`6dQ zic;MNdSNAkp3=cS)WL4W1TrdhdU*4(Mi2ylHF1D;i-qKG{C@r!ejnt|g0Au11_Yrn%lEdwjj*OVQ@vC9QMFVR%%= z1vG43K)@X9pU3gZVt6I8mmCgtPYIh_6ysVE2U~1r;@WA)g6Hh#|N69KtE|0_Qa&`x z9u9Y1ZE32$P@nrSC9O<99kidR!FCbSJQG>o+6HSKHs-E#=j`q7nB__ z%@~fke4lKdR|eZNmEn=j^2+4-XT>bcUB6V!hD#+t#PUbWW%^CE9EPue`*tSt%~bkp zsSyh^=nI9MMUt3hh3ntU-|8sY=$IGdlFM<=j_?+)^Uqp6Pq=bH7W2*0?Z0l!WZkOR zcjv62`A%(j?}IUAzml>du6tylxBFh>gUW=n$)6T&U6dU)ZSUu_be3Cgj9(hlH95jL zn;%fLd3oWMH_LXuj`zodT#v8yk;cAzIcarg<+hPa$0+jvS^LazR{?2&D_pe586XZy z*w^LVF!+06UlK9PA&$t#T#^(x;R3G}((0Te!ZPNXQ44r1eU_np;e6{fY0;>>2 zfV5%KWRb~94m%k|1DujzxG>f@-<0V7=2Lvj_kN{sP(uSPm4_I=xgg$ckGs$qv`Q!x z;3&|ah+xEBU_HXCJ@3N`O$&`oa1G3?hI8pbf(Rc;xMMEE75Z=q-!Gr%ogL|s9^oZm z&lmESWic0kdCTW7hD6=_$()1h0xx8Q>z@`u+^bBczV3%tYm0=t) zf+-R1X{_0Ts2RC@hr;N2712MejsCYHzGpGthafrDuQ0~HAlgsL^8>4PhU<5d>Ih&d4^woh^L{w=udb__!H`YGANEY_k_?)RTRz73wlKv^*F?8KDTqG)eApKq~}A`DX*a2B|R zw1hq<3_3adUr+V7hyN$|`zt&vdH`dK=~?Rjkn~NTQX>eM0ToIj-m&BnY6-WA>5I5c zELb+H%!CMJ?3wJjBT3=EedrTf1=smhlw%IVGl%H~-B`p4%;wGqm{aHh$HV+CZ3@U) zGxO-j4uxCZe||Q_GI)M5;@{8P`p5EppPoq$ zyDH?~k;dOI+}K>ax%q7R!}FPsFA1Mr6?NUr@4Z_*@SqFQSM#tpu;bH-%3d zj@&5RdM=B9FO`4wNbt$+zmZ10E}*-@tjmg|30btFC|Yq8ts;76U7YjTIIpvO?^8^V z>M%?k$IQ>C9bHK~80IF}^~-Z*U-mw^YLJg3e2+qE)p*D7oyr^8apfC+R!sM=i0~+m zaxCRLRdAik*)D}lcdQrbtR<=3<*+PL*UUNasZ&Pm&zeg1Om^LXRYyWxEeHpJM75w= z0?Lj-@xXZf2Y9B2uT#TUFfz~-?-oY&oZAm@L*OH{1mWCvomnAGj6Gd+3<@?}1NaD$ zgv1m=vp|(bgoxd7|4)G2Z@$DSJVW&2ZZ+0X%GmkjoFIEg=!M#B4K<0KWUgZEL-{uZ z99YQIolqi4#A;T(yi&CNSeT!P=~}hk4=%hswx5{eo5%4N^8&=&dAS_FY?hB5-d-ox zxtD+OZ;xvBYP%be`mOD`eywDmVDq0ZMbYXaX%%!@brh^KKLINsIdWkN=M4$nqlD>G z%L_Qg52)pPm++lLQPTxHT2%zCKHB@-{-0jY4ZBx=u&t@2qxs^C$9D#X9t@7OjE+5= z7;l*vy*oD8G}L=(;KlhTZ8zH<-+0{G^yuNWmgXxD?l<1Md-3j_3q5UTd)m&uXua6o zcD=vj!B~H%YGT-+oNOI_`E;=Fd0$88^OlYWm!CCOx1JQYlxJQ#^j`VqWtkCP2qrnY z+9fH-J1NKyIzt(EK?x)+&oP%f6Tu;1q;u)>#PrunvyR+oDD8QCNBOeLCVOcaZtuQc zb3SJupqm^q|HL|1VTf}+)4hNnkQ*JC&hrP~WhemoQ322aL`*jk zeXclsh9qKo(;0zg;t6Iv+@lhAd0uzLUv+hq&a}0Y&@(&>a%` ztOU9@@kd9`$Y9V?f@t}X-c7qd>d)TU^SEWC_c^M;7>zQOa$unA!NaR3uUF^YFWhlU zwBcehqi)}4C7a*RkA5$Y_k9ujts=%uG{kG@@8f6IAU??atzz^t9@@7E0WkB|4Zk3T)r+j!(& z-e;%wEG^>COb(|Zt|>Rty?`;ln65tQn}~M{$Cfd+{GcZA_lFJPb-dHBx3mr!d=C5k5Zn0d6cgt%t^44mbxS4 zY+=H1$6ew`pOP*AG1SZxcQ4h{9Qq(XZc&YBn_X2l^e9P2y#06j6Wc=C>W`!F0`QC^ zBU$gwa?xRvqT8-4VStH4Z3_DT@p-;2pJMIOVSND~fdaBrkIH0EY=XU^8+<9ldzled z0sK>>0GCZk*(+l}EaN9eBt4C&ASIxG^tBbQOQw4tUgMCzen~dlD`i^NvKkp21w473xx#u%_+NeW-5;{=6)XIUekn&-Sj44Uj~-7W3zw-$^^OZEkst zUv}91jF5#Q_PoLkp2eHzj~auBj-379j5tT~0zUX>dbSH&&Kqx+<;bU3@-O%ygWBh0Hl zVf9$+DGVHj=jAxW3d;Y=LEk|Y1PY;S69)j1HZbK3qXXTyny$1ydW=s2TBOf|@w6HS zIu=Fxuq3Pux3ppl)>L*!OHoWj(^ zx6e!*pCksXMK@|TOqtU9$sveM*fJ2ymfpT`mCkHHr7W|IP|!w_eF3cvU4$B3=p6eb zmtQE|2MawR$T^GYmlqW%WVj2$U0?>nOv_~lWb=0zV7yg!Ufq)|Z z5xbMosMnK15K}%EqHhCvXcpuzpkx_jkUiu^R&Zd=lj~xnJ@yjUqj|FHvUu|cNV=KS z8UX43Aw*^4w!}|Lz;hJ<$T94^M&jMm;!mR3&qiapz_2F7b(M`lr^`8=X5H@xs>Bn!gefXITSMHNF(6d zn=THWhPczLbu=M~+?bXVG93aC{`9*gY&DJS;r+BEi~rs~nrfibOmY@qeUm9%Tg ze?pXO)+$}<(k{NN) zq#y~&1u*KAcKrlo1@W+3v=aoUvS(#SKelME511y1G}d-s+VzJ!mqivWV2n{FK3^Pf z{KWw315!Fj5**E-ki%n6j3y-Dqxkl>49-LflSO3gVg2FATa{V8_i6{5CFg37?b-gv zixtPH(QXntPUNtSlpMDQ1K?f&WV@rv-1ne5BmT!HLLA_dD2ZMmW&0Lz{j1^^7a_0# zBAVq@#`QWK?^X51&qsP&(AN_k7c!!j@A(VuRIJ09jozg^j~u!i6h(XUDqlbULF}Ab zrsJ{Dfa5zpY`QEV-6-!Iy;FBK>7$(Z@9$gdwQr3p91z)2{*qW?vyoNJ?8vV&%2t(}p+dV1QbX{oDcrmvYJ2yzsJI3Egs^BCiuRQ|t+w*0Ts zy??GhzUo4H=;bW>%>sUtly@zU)0o4!kQH$zJ)|KusQ$#-QwNsS?pjp3F#x{5+)(GN z)pG@(Il%2G<+)3vJqzQ!i#GTcZ1fhdcNfOG2%?=%(B0A^W(vY-A||bPllQ3;zqx*L z%l(@ISq-^EUP%Hz8l z&mI>X-1u=zeGWW+T7}AAH#}XLk5v~%3R|$eD zSw4A8?|hEGDAFt8bGMp(zo%raGL8P$m8vYxk{bTpB922L*G&}Z3{o0PyqM*V5H;w% z8Ea{o>uCA0%b%Z0vilJXEe)dVt-nu=S_;CXh)3e?z%z^aJ}H0=%P()^8yOMq@Xlm2 z{jwu{1fd>+5SQ#wco^Mtg6F{ZSNG*FuL_y14M{!C^_Wny(QZ_yK|^5}JMjg(0JE8h zp{Zm*uVyWUS<|D%JE0bj0~ zz2|dUQYcLvJ-uSf+=|%Ql4#eosCkIuILcp^#P!W!P6xbUAe8O=*ZRUOZCy8Xc2D2n zWE@il3>J_nEPR99G^4+j@Uy)I2?dJK_i}#hM z#EA~Et?E9w6mcjOi3~yewr!feG4+kI!^5ayh!skwQw-i6B=`n;<&)#7|$fSfBCj|$~P`Wlx9w(b2if>ljSE_zr4IA)k-Qij=nsZk`wg( z;~zQXv7AdcyCei5G};^db0MNTI4*@;SG<8Ir6Se?v-7!kvLn)tFCR)ZGNC$7{b~dKA)E&B3w7nrKx-ywjaxARiXmIiIu!CRdeBS~bL2QWVjoP}A$9M){%b`o zd0$-Ev$i_!w`b#*R>1_O`{jhfr1giBrHJKM!tzau4oKrVWzj*T&`LJ=UCp5*;1gmF zDJ{d#Z?)7MI(O_ZCGoF=00f<$NM9mmEv|}P*bwVg95Ew3#4UT*imO*nza+|R|5)3} zsx~?tdT=Y+MyeFbZGD4j)f*p|80KF(V*!#kfKN;>Er_4wXSHLfVnDeRN zbJ+MOK4w7h79J1-d_&i7t(&}+ZB##$!AL};`WShJ4DvlG+vvHv!-@NTM^TN0!BaoG zTCk%gXD9H0{4x|+o6@cc7QQu`RXL7T>2^(GM(n$z3K<@hb164&baWJ%q*TGFggI+3DPThko94x(ogdDrj)V2>1=0YVb3v33*g1ksx(B>w8BE{OE#EUE z(8Zv6dO?`6dR7gKR=;Ce;g+`&*33K}xgeW2FFj<2C}KuYY`_WjYto~^2eMd{4>;IYeN18d^JUwP(+%sKHXErA{={o_^xeDiyy`%6!XFxAeQLs|mxazKqq_(>F0f3|MVR&CFh@j^;P~ZH zPWNgv1|DBSN+663B0Uf`Z$b3De3n}w(;59!%=XLHx(UMWu$I4cjJ%A=V(zl?J71_|~zFe;9fUOG-(qXi|#F z`{InPA4An1QIcXis1pCJ0rFoj#Axj!i$+g><2KMd4{wx6c*~5v_pzXyEXllGxu2ps zHPqNJ+)2n)8Abq$$^IBAP3;L*%Iet-agHaq`k!EVp9q>!vOW;m)qUEievxiM)1+%>76-dj(F3Y@iwmO{rSiNF zG90C!gKb`X>flG03-+|%KaY8#x0oi>ing+C4g3F?72+=V92zyPVXI5&dWUp6O&H=Y ziv8Dm!RDTpMoK@3%1iC1_tx%zKV{tA@CI2m+8L(>D%%Dpj@uD;h|2r5iFr2W6hOklfv_2f10~1q$qhK zaxLxinnV!7y9&3y8t)8>!KSnmkv{2>Zh$W0Ig4UnlZ3b(xZ&(8NH&pBLxJ9Dyw`$_wfG;B_YUaJBH0b4hT`z8DL>>N= zb|PpFggi1(VCcb4lyCzu`cmf1I=**Rq?cgjY(&u2=f<|RH4nf-H4Gwv`F`!;>O&uj z`SbD_(`q=h3y3$4ggfRn5pO97!>kCm>~II9lhnj}7sU9(q>@DW;mElR|Lh3=?C^l> z@IZv8qCx+hY9L;wnkdX$9O0cu_mVQb!Pp?)iA0PDY>ysh`oLbeF2w z1rVpO3lJHS7B(X(%)Q`?Uq3#XXnxTIPE;*3JiXn}kQ*i1@(%cXgp?En&p5%HmCJJx zhB{;fyEh(Rq3^7OEYeuIA6B2J+VjV>(AmNWnkdROoe5uze^KOu`dE*~&0Ymz(~hk3 zDHUva(f=Hwy%^JBJxNH%b7xTIo%j`CP>@<9B=8$JAM9$W5g#Z?+w}ByC1oCltRT|3 z`&YlRI8d zSxu8{`}h9mEx7sKrkwKaKRmh?UKn4HY`}9a%iI2w03qEoE!edp+%IvRbHe%`G@>lC z3ZcSAYUuLljqMp>K1pj_4}CfpPG^wM0(M|3)9-i~vi}@PBWD$a&z3|u6>z-BLL9RI z`G#fmc|~E~l3?fDb<=Z#X`%=y612i78e(;_IZMR+*Yo4vD%tddifuox+4heqOTqC(^j@XY*c9XDmt%^G^)%EsAu>51*SKGEEvxL(W$%i*`0<+T{&13+XeF zoPu=({M*5mPKSa5b2t2~`pC!1XZ5zxyOeDN18$jYe|kBuDj_t5`=ewwO~9c^xDId* z=F^?wrp#o}(vi=&)1$d0#N2a<$jotd=astpRJwTU_fbeh8ZxUm&be^A=icz?>_5;B zM*PdgjP0nE2SrOZ*nGV(4$}=+g{SYF9i=s`05ez;*YXs??q9YO;5jWsg9BXgkm39SFZvnQ9=qCrVO-g|^8d z1@$j3)n-o)KQ$1p1E@yms!fTCZ2$|HaKPoSv8*6{jsJ)T*O8SPI7R3Q<}GF&%E#lC z=u`$=A+p$PYLq7=C3bMnxI}&H`P@YMQW47w6jpIOd>;$4!<>uaeKI2g%A%JRu-)^& z_#Nu*qsJ-^eX#d0G(fs|{bGb|qy{-idH!Xw3&ERxxq?=5;CExa&r$IBQB7VQ$D=e9 z5tX#cElY~x=8L&L!1Gk>M-Ia~GtA>?NWl5rjUzozCpE?w-B0e;9XY$_Cl$f8dhYZ( z-kh3fww z)hLZ^tvlRvF?;x0@%YWku7_v4ThI4DZA1;F$^N_Q;THY)W25YeRnu!yzR-?8pM2Sh z8Uj5}nw~dbd3x{CjjD{xMTbvkZm2l8O1kN1+3dv`AuefaW|cB$fflZfaj%Ic*y)tP@m0;pQ%c!^z?BC@!uq4p>AZK31v_Sj&jia+!SF2) z2{;!Ir#bByYhF<*rvsLwR!+$$bsf(uGq{=S-^&VdJR3Fp&K8%GQ4Vl=9t`$97X6b8 z#e2qHK0`6R7d^eVPh~Xh{~1V++%QLYtVGdoLYSP1b7)*Yql_~xBg~&xDlb`oXCULQlML>9dwPuni<_XiCHeFIYfT0v3F!m7=0-oGJM^xrr3J-JtPLb&bc$!rfys4~U^!l>{AU}xpC zJwf{Avt5d#+$&?f>mq0+AvD42X-8MPALsrU4<)>LUfk2(G}QeJu}1Qd9@Rw8E_6P;*!AcV+Kbl4fu8$=eJx{yPZeV?K>b)yYy`#b zP?`u??__XnNKjP`JRE4QYdt5pQ+>2<-}~T!A?@Mf$I4Y4vk;uTAk?We$`@vuGz`Y3 zW6jp@T@{2pId`J3rIxHUC~u+~S2Z`@%-$u9|4n-28v^FSJ9f#$2Ct&)g0Br9grMb4;?nO@ALWv^eF#qcbNdHsIgMp^qE#n@o` z=g~Tc`NhB2?|Q#t->Uk=(Cea@w(2i?FB~1Z znml|h39awK-p3X3mr_@jZu=>c0uTfaTM{NiDc1`@q1EhZHB4GLV_E^z8Guh=y)HTa zq4fC2b=eWkr*{tDKmOv{wlg_@NZ#U~8@m{CwS>E@g1M}WxrnfEF>shVx0M{S4Zx`Z zN~O1`^vGfUd->tsx1v2x$AN#Q306%Pd@`+?JFht}a-i!v;_$Gt+$-N%61Nz>PQ*8+ zM=ek0ya94a9QB$6YuV>6LjK!BH`4J08;D$p-3g@%NnTi>Q8N=Y*zLj=901;s$AsYv zas{bk1<8zKUr%3MmAxA#3~CNT6vO?kL}fyFjtOp!U^79dkn9662`FMsBW|DK4R zd}1DMHjlQNCZ201dQcu5JO)U0H5ND|Ug9wg(Dy;ok*eS@8ckz&jvWv6s$M^@n(v#> zBqkNA#vy!2!1n~}mA1~~QDYWtg!PBq-OV6Q>hKm-Vcb3Q*1VP=reQr`RnE8U^C9Gu8X6ZpAX|XEa-Dp|Ba@?joC48C9j#4 zv4&Q_p-GuEaX1Z;Z26(H%NbtvQH#&Uym>O(?HgNFtanAUXBp3|Zfw&x*NUu5dW;(e&gsjxZ7>OwR&_Yca>AF3#)x*1%!} z$noc8^Ot8ty`9Ec4yRsTq;p}!v@(t_1ZEmk3p(uxUQu%_%=tu!&n5QU(`=7Y<~$*Y z%E&+vDS0t7N;c5aKc*dB<(jc`#qFk(BvYAE+&e2uTL0%`pVPAG&Nb^7)W^?5h{%zT zXsL`v<%j;<{qUSw*<(?5HrF36*zjf%*9rU*u`<}pkx$XEc`?G&4}D0>TK|h@H%jp= zU1Il}b)+Jny~@O-#-1EX*`AM@;E^F1uot?4)^WEXGmpCnz=uD5WI_q`1Ej~$sLWzi zDn~jf11v8{cv3L-D{nG^IsW~9x9j=wc-}$z!A~m>uc}E5zf$n!!?W4<&WOjyU)Z&2 z1XJNAU=tEW8eZsX?^joj-zMq8NBmvg;Qp zqmhe9Bz|D^_BV^-A*tNpXMz3s z*gn8B;xV9d2*N$ngJ`w!^BcDQQWEvHAj&I$vsZq!U)oB~il{kxku%|NPi8JDKDhGH zxeQA26vBiWI@@{Xu=I=H?_L%7<)^NR!CnY^K-~;+$Py`i2~x{TqZgON1{B1&iMVsJ z+0!5`(Gcf@@Q-ZH!W`}*v|Qd|%*ssqLP6vrXvn$TB}A;nER)8*ULL;?@k_YKj7ZN^ zx>p*@KZCna5VN#A$_JvjnC*dvNKrWSF&B`%2$nc4(*JnmlEaa29F1I-#+U~;5Gd$# zTO6vmPU5wmIja^+L*6c8yb1q{gfY8jofopj#cUTrjB`f3t1!kJ3PWy~Kg_^foUV$o4Eq1r!(q#isJJ%$i*-5Sv+FsuGn-s+YdLh1@B;5lRboinjf#g?3JUgo zkhErc5uJ8!lgsfSPa(q>N*aa|rbiZ7n#hIK`+qmqdBKiD!{FFB1TsXcd{P1L_&72| zp<$8dBM{l!(|k&>bB+3W11W$5r2@iPZL!;u`j;)IPNv7*I-NZ7;xYyTg#u(ME%^w) zCplh!-%X*J9O!Qw>AtCcabDJ3GTbC=uRC%sBc}Z+m^u;wP1XqL&nOo`9*1KPZFw^( zXb$3w>f#rru67qPmSU2Y#LPqeB4lk`k*u;QTAZQ649Qre_9u3u6`+Y;aBuA!Hr&XD|{_IbaMTxev+!G(#vM zX-o%HP|1v(pTn>daU7?NNaqvbZu#4O^y0!E%G`pLu;HAkd$y_Et0Sne;q7}H&el)B(sL$Swb2e}Wl^p$5VAN61mW%=z=hHC1kv*{I02Y+a4Dj0-oe<{5|E6>4lHE)mN9$_ z7(SVizKI9|4+%ivUwPczs`WGxhnB|iEQy4s_ia|RS;{=}nPzZ5dW%HLHE14+v48N3cKLEQb#vfm(45OuP{>|;Wqh>`1 zh8{)SNXaImBmjpNi>eQH9%{T(rV%J|S4;K*@Ys)(E?9r0{vH@Rb%%84iuSVgr784^ z?2T>r8z8`mRR~KAlG;v@{apcV)S~Dr>Lem2f9lF{Rd~QKLb4R7PmTmkJTe}y*kIL~ z^rLB?&wv34zca!eMLb^;UCHz;ftAN|-nqhk^x1h#$&%e4mol9Yhmgov2ofxty+|10 z1GOZd;Z@A^s^!nC`8PYUXR4)dbwdJR@h83*(DdlQ@)&oL z`WHZmjhZfDO%p}Z5S5BR<)r8z!Sh~?L67t~5$;nJ?S641bPUh09WHMx@2H zkKRl#+V)-^!$XRCm0VxMzGjBIVu28{P}~V6p5|w=<{|Tu)Wc!>LhPg2r#5DH;E6Eb z!@=`JJOA8vRbtlR5qVUvhI#^i)Lu1usz@n>+t=G9G-iulrcpw0gGR7EPQ72US+9~C z%>6?MVA>QiIt*VIRoN3J5CLjtQ>LD;bWKO2?+;1YJG1tCfb;>@(;88Zt-A#gG%PO`DCSK+yk}`=XsR8e&#C2kmW3}k z8oE3K)Ke@HvK)@Z{G#nf1Ep-Ily_UpH>Wa}9a-%PnI?^2TFRuAMMIZZlo&KGaUFOP zl=W~g7CY^q=aeX~VVyEClw#o60&8~0Yz@KS90B?BrW~}uw#8!msjHZs);TW zzGHnQ(WQ^t_d{JL1X`Nnvy|yEKGSy!ff6w;laPT^<|^1wihRbQnb~M=5NI<#(d*4r zuh%zCAIhiR>r$6hpU>Mk-3TQfz7Pn{ z_>!f0qJJ2LF*66sQXHLnr{OoDDR$VyPQ>!nYmute5}8kA&|^_ek0B_rQ5?u5lU@?=>YBjh5}O2$xrJ zYQ<|P+2=?1k0mueJkfW(f4Z@++WhducdPeLl?Cvll1({udf%PIg&tgd3Q|*%~40XM2vrkd)yy0cBm1>qO*aVtE4Wr{t`9_ei|` z-P8H^&TlEZy1SEmO2v05W7-YS6`zP!TJzkRdaiJLn};!B9k<)Pg%9d zTLJNK<-YBy^UUA6b8ZVVG6HAY$#qNLpLF4Png$gI!0l@7{T5D=+(ifg%F5f?&Z;&| ztq?UN{``H?bDIE3L-;|$pbuD3kn8J33MY~HPqduvK;)9<6V!zzE}kX!5_R{e7;jxw>?= zVT$j-4587QbmJmUUlosv;&9K4wADc-jQ0FNu;awd7W%PvBZ}vnt)DR|%j*Y8&N?fn zE0Wgywc+6&1R>?UOUE*O^87#Xcl*K0S;IHYc?r!%ng>T$1*oBD0%IKv!ki}yQ;5A@ z+QPR zs20=gh7&sj(+;#ST07lvv)vm-LDpsGa0i%pgEZ8SLIp4MhvbeeO}Xpu1EV&jMMkgA6ks0`Jxgb|ukQcvyo+1oQF?j5IE0E2G2{*&kJh=C^pU&~ zh%qQ_gz!#}nob@r?3bSHU*3_unMDj_P}1BXA#;pl-KL=J%yxez#bGpB0%EI^7XDLP z2~e99;UI>y&&tB-sn1-{ULWG~>u};e=DvJwYal~$?QmwqEF(1787?|m9>z!r!o|pG z0=Bsz>v17gqXTB?W-a;I-D9DhT~$>z_jabPj&S=~^aqOcSpy24jCXk9t1}_TWeoZ; zbO<>MUMZYECf12yy;tzB%SMoPnvCXFjCr3`h-rP*J}-XJhmxTYTVwCq&vONRL5$s; z$T*1IJdqdd@}q#MiU_y2a4!L$CkiiU^OuR_A}TX?!4Hf4=Um;kL0gHoO1Ra*AF*y% zbMID7cUx;WQ;USz*@+QEUO}}DP`6yV+cnJ{)`fK~@E|efJ+&C6j_UI}C2=HiPm!L@WeEH1I{^&W~PO+;X3RTH& z|LHllgE8KPI8VuO9g5(A7cN{n+HOMZygzG&Z>K;~5}Hl9BGAZ{l|+5^L-`ZwwOv`h zb@e|sPg7)WG6(tc;r^mn*PpC0SA^LKH@r-@kwEX}I2#hg6k|6o+~(D_R%1?OdT1Mt zYa6cY$?{)e`>SOi4n&WUWj(0K#jwO{Y>xBjsM!VqpX!Cq8XIf(dWx$_{(>=R6#{L? zg5^@;I$+&2J$%XfS#)%O8SJw@vj+QKu)Qwm^Co=Q>$09d84lj#BL;1%ZXJpYoU6Ol zT@hqCiuH^66@Qh@=K6ltufdSjceZNVaKb^B6dOHY8qKX8^(|d>ND^YKsjv>d;%_R4 zG8L8-!0GX_gHg*>Oo&Vaf)08Y!V!@cXwZXl3~(J?wU@T%1i%lQSScb2m(ZI@;)H0w zs37d&iG`&UA_seo6w258&i~rq2fp~(mgT=q{_?LepT8IP*?Z}W-Ys1H z;r8HZH?N%#{J9R}^pg(#BO>S3lA_>Jnlr69u5a&AC-~P3HLaW>j6YPgz zTM4%}3i14zR(Y1W089x36P1IeTp1L(_ORw&Z|Z7GOBTMJ<~rrfg`<^K&ACqhQ)D+d zXz56_yD_c;JuKMVAab@|rsK$b!er(QKC*3XbIsZM`)4!P*sXbYAif-X7wZ*%rXMnY z%4YZR8=+h0QSsj6(tO7yx*A8>3|;-cBGGX~h^-0mO(?7Pd%uj&UfHb^0>Z7&`g9fc zEJyiG&oceCZ=TtWp6znq55;iYBJdKqvb>HIjUBg6r3KoW?EXx+=N0*k28D9{$BHPA zA3r!6+o8OJlO`5w7%oaRl}MW_uLX2u%{abcxQa;%6sUpm6a)9f|ZO$W;KwoqiCv1ZD zI%$jkoAiI!)1}e-h7QQvSQbsZOL`|=t$ z!(11mVlTagmZl|<8{s;2XSQT5{Us>4g^ngEbButJj#*$D>!gbcH`0A#r1g*!D@Gq& zWZ*Y-pr6A}b_F|!y8SZIcS@kufN;klVCAhbAKP>+qOKZ`ZvdCUdILyYa2lqUY5R|r z7JM-^%BC(-j}er5`)~%Q-BjC2all3`FvEc`%;Oi8ch3VPAmWbj@$IL4@9pn3U&23A zgq~_2RPiXBt&>(bjXiZNg;;>XK#y$!wp|bQL(i-=)&jnr&A2hi9&f^V1oG}CfAqi5 z$lY=Cj}!!eV=1uEkbzn>=MENdx$b6B_9n&2u4s=QAIk{#dVAH(0c;St&SMK*e~{)nd4u^- zKYW<&jS74XihXoeysL=t{OP{5W$KF4+PWP@YyTc(Z32#H!Qxj#tPNIts&^}Y9xM%9 zGccdofdwxUiG5IS{^v>upxmt@UyURWko`Q`QBmaiCU%oR3!N=%-%(y8j6#Xagz#^} z>!zRby?3A&J-12loDZr_*OXt>k_a1KU3oET{_k==f0x7uWw$S}9X9}mAVLH9P7UO; z>|jsBL|!C`;JD{^ZReFEc@HjQ1W_Z&a~DWj2vY3+txe*#Y;a8)l~T^MOIomobRSdn z3D6R*#aW&car(u@2oIuYXT_DoP=qxZh_rss>-nx36>{{9@ ztiCTkHO}@N34lMaoM0;zxV-{=!Fo$^Sc6qs=x7i-} z=e08j5L2A)Y?ACa2Eil2aV!oG(ar-e$9%y_q9n#4+gt}8h6P-^``Khl!ra3w2n{gITQV-tW&~D) zEZ;X{tPN8gjrPnRhPTg(+2fAvjBjWm+e71ljHP=w|82ANurLh7PGd=Qm11j_={7dq zd-U2F3T4$Tm@@QCR#1jm)(L$7)bQ;mjrePV69wPmtlstDWI~jaf{3t4%aMqxm|qmoeB#;4K~!1;{ag=Dv>aP6Nj?AU0q9n z7&qk_Ud3smtL^-@Ma!lR&haqDq8*RBrso@&Er?V_E71 zseE7j8F{Sg!4(|3!knkzMU&({PK1*?8s^z5BArIZx=jk3JEA1gO50U)_xw(u_YER^)XGs@3gajZCyVP`<9RbsI>H;eKA?!)|@=H!JJqiqub02ESgbXH!<46;@D zeWH6V)r-W1Bx1f%B|P(qg;Lf(LOIo6dEqnul`nhIvq*={W-s__+pQ}JUpg8E&i~D$ zOGm5Qv{kj_>p<(G!h=F0Jk{ZyNk{h-h}1|@3?qUxQM(#7y<}m2x55L3?vW~#F8rK! zGR$a35bavX+|LoLbsEwJP83W#+y+_mI) zHT73+pWYf_t{3Bko55Isb@BNcm(bjsgb|#oSa(%`EM3ZJcENT9DAbHn) zV$f21L{)!1W0l3{9}h^i8J=!umS{aO@3S9Ax#|mPWS(vqu^#S!&{m(;wv}Gq@@4Rh zmkXT~xvn~)Hin6=BZn9a*Qy4A=DA~_RfsJ=}wJ2{UEctVq?cf53L127^ zIKGOTR;ugpXa|!l2eSwF4r;3IZk{nB*=;DnP%&=fzc+f;HekRyw<{*YZXofkxC|jY zTCI}VNY&;eI@!wl00cki%Z zuN19W_wk^uo(8yX#*-P=)`Y+Wq6V_&y@LNIu&C)IbHS5pt{z!sZ|(Hcwy3ZvVS!*b z6HG@?%zvnmBnW!uWTR5T$4Jz*)>?5g)(2&VWMyLpTQo@cPz@DKnEzj;7d=ad=xSwK zDUE2USEB-KtWnkpBu`q{QQaV+e{{C&$PLU{|M6bG-|xx_#nQ-EBJ}`AU5Jtnh=a>_ zEku!b)@iy?o2Xk<=l7+iulR@@B22m@-p~R8#n{r_EzvU%RBj2djGjRt>fl_TNkr%; zcuz=k9Sl%;y!oJ;*S6!_L=;b|=dfIxaWNhfq37sl^mWRLyZ@TLj`k2cw>!(P*m)q) zF)<#m19*kEs{h={(cU9sXDCj`FH&ihTjRXq{;9~GufN`25dxsP{WyTov%QQ$tOog8 zjK7z)o|(RVG}qtejm@)+2#JdH_#qKAX%2%^oTfzEjfrFrJ}!C&};K&9190>S_R@=WehUYIf;gO4|c=4iJc6SItmGss0a*2X$xmLgNIBHrJM-Q`r;;+Xdpd2Zu^=NhFs3VIfi zRt`GJi~qZ>;tqWlmx3Lr5gtR0*N-Hu@cffjdspIneD_?%xr`@@hjJU~$3m{93P%nU zATE!b_l$J zev06JPsapF7}GhuZpI)e+Kx>0C^uwM zh+;J(3dv!m?hwHR3=J)T9}?r=&tt^}G_2`K-j`xKX`Cad3}52OrylP`Y}#p zzBhWVJsvafH-uf}IKNcrIkdpbfb@kx;O5#5-R?6X;KKpYbIsCSCr8iHEAbjv;tnt) zaf`1+IZPlHHQi1(+(Nf#Xeub!?rcjWQuBUKlUHQzYbR(hqq?l`asjg^lD zfiwNLu3ta1t^VP@+AD>iG%N3)Y`nd{^X|4&8OyguF449>hS>V9;H5~Fl$}&mzEqIO zp^#f;a6>@=CrYB1Pc_^8=>S}yBWy=U+nEs%gzvY{9~B;d(@9w~qx@_dkll0;NBlZ0 z;=+I^m>ak1zlhNQAy2qWJS`l-YK2JOloz%I;<4Q&8&iD-;2#U4Umzr-EWq>PS)Gtq0&EeZ&}R`kLy<^MD8L1a7lJW6T3JU+i>9vr#xZTxS*^Bg zd+yp@Nz3mRhv#gZRk-2(vq`g8Sx>0GoF?&7)F9P(NkP3-_%l!Eo~$FO_W4x4XCnX_ z={6CLomJ;LHd}|6RD?mL>(xOYZHP;D~b+{oN1c7YSq2GMqEM+VvY5?sDNd87W)l38zrJ4{S)9qnf^g6t~z(IvaRn&CsB z>+mo~gBW*M?)V52N!Sn1o<9mzUjBktGTn{I&Y9~zBExk=z^s9!!$@=)OpZ%%eN!AJ zkl+$0v}E^@Ig898{USezY?e}*ajkCiKFnq?#2^KGB+Z*IL z7!rB|npuI%Nc>NdY>Zt3DAno|QCMkJviPPo#LE7s{Of5 zMS}%UC^v++MhE@_2-c5J-j5bcFZu%~q0VQfjcflK4NXKa;Ey4Gxwz;8^w$p4Cr56us>dLd1{3hIz>>=Ni{9L^!&huxRr@j<#JB*+$ zA}=;i9TIJ!lj%M*8ikcL?i`Bnxrz*r5%G44C`(0v`3T}YftQK18U#O2aMa20(A%|a zY~i92`MyTUc1B4yW73^pO?Doa=w_JYt(W!XpIRSXX|Ab_SUG*u3`LQvah#o5g!dHU zo^m`!hgs+o!%Gz2(L`G)fny;yXG~EnbD5+WGBMyxS3d>UTZUSQ(895y1_#aqi3>J3 z{K|joh%j?K0Q{s_yH3EpU9 zkcIN*jUgb2*ehU%ZybqHs~>}o*k^^E%9Yf{&k7#(yM05+2s85~wz;Jr>J$Y#wAGxi zdU!F++SG5_plo-uT}vn7R1i65C~BWDn=t_Hh1pFy1K67IjnJZMlSmnw>9-(4GZ+kt zWag8YDmz6B250qS6%N?V>e6$U^214-iWk%FgwHoGvwraC>|=Eq5V3UxjCW}31WGkH zOB@@p>A{}cySvCwhpB~?+jkMV5r|lFAg`*Y$6`f*fuj^S5{2-LvuT?lpH0 z1|LZO;$+UsW6ARm$1T|#G5<*X(xVBVpGsYEId9{k*u~kaZPJ#1guh4b(zjDUEAssD zdaE((roS9&u86lEnByzy;;cu-+n6RgnGrh!7GiFg6U+2OVRneEZnnK56&x6+pZd9) zBC8XO5aaMh_#DFmPu-B&io+?sb&pG*o~<}p&CW^yA&Fm_L} z-nTSj^vnr2kNn~{8|;nztzSxT8=Uvqh^+a#@vejRtuQY1)yr`+Wzj{>83X3VI`bi` z0DE^B8#>E4-f05VhWReS#k$)g`#-~Hg~ zPIl4|hY4R={n+1T{5Ef$EGtF&(*J41JH2*G&X<2$`j3Gk9jfbifzf3DYOvEA1@0q* zXAVtT@|X77Yq8x zA!$B8YPx-JZ|2Gr=a;@O{#;EuO4hpAQq}5?_UdL41y2A1Coy7#NxlQQu=;Tu;>=JF z92KyEb=N!Z@2k18_1f_~a%Uv0co$4m5Hm0c!fA2Zmkuum~1;K+j)!tZ*Rhn@+s5Vf0+1 zSj*9wE>ki+UqdcR_5#bD_KzcKo(x$js4Hg-Tt7=c-0SCnY4=$ZJ;#wpCdP$Kj>hDI z39!`hn>}=+`QR*{iGbT|c6<4a8!}mN9<^b4I-cwnO~`CXBhi_s(4<9vXMo> z1ytAucjLEeAlx}lHmj8Ft;&kWw>pUSg7(`RI)UEq(vqf{r>IYD3j0(6f>6B2YaE@j zUCaU;UL`0#$4T$z&amBu!CMxL=ta-mYa!tL*9w7 z)d?0L1H=5yUkjcyHqc^toQuwurGNw)hMViA*iOiB8`qzS;5YgE7*Vu?goh-hSVfaBa%FlDe{ny0!W|D*5g)LzY#Edc#*v#CN@OdQr38V zOO)3yK|ITLGsJ*J#5ZnQko3xT6*b2r=rz8@mGzKHzxzI-Df~wyB@w+-7Dj(D-~3k< zCz4<{ID%H7s|3lG8{mSZuGO@bHFs1)Q{@17z>!EqELKV{gF>Qtc^s1!1Q8IVPx@#6jLK@3fs8i!;9R5K8~*or$U6iP_oC--uYc~Z!Qb`sUh4u9swum? zGe6L8!Qa=~O-%M4Rk&bCo{J*M=jVlA{wBdw3bnSIlw>_F&j(B=Qg~0mwzAH};Pmdr zQ9f^{nCq6fk3!uS?5x=8|Hns%6SdXYp9M1j*0x)F7Z~%Fc9o_bY*^V#46hgP(j*mf zUri@GTGgS#^2k2Zrg?n*RCe)(=%=s&VO3^as!83VZn%)Q0AVk};^oToyS4SGzB`qT0)Yl%Bi93y(%I6;PlyEr zN>SUv4=c3gyY_}T#CpBgTy_{`479I8KS&rttH^%RZxNE6U@X{W(5OgW96SVX_FzVdAy9*A%p2*OO z#}SCf1oc2@T7=F89pLV7h)E29Y{@IC+P?` zy^V7Q#$XO`9vL`SC(_v8++d_0oQA~Fd&5P0T&7l>0}q%$UB zp*CMBSja)18nf^tZR530Wf^0mBv?!QnqI@hF_~~u6Jw^SzIE?-)&`G%6omRh#ZV(+ zNo`Au8ciwjSwaTpC;b*qF=XEsWGzO%q4e6xqr0;=I(?Ap=Xtm&SjvQ35wY0%?4D%w z-V&0(P;-Ee%1_94bUbU(8gso|Z&UJ)CD`lb&YOTobkH1Ks2X_l|8w+=3Wzfa`w+aL zqq^dBZuUBhFJ`_LVrhVFCEc4u5<1{aMq8O~G9Mb}WlG)?5JyuNf5`Bo(h0D5DZyS5 zYZHEFUC~CaAif!p_)=p{^V2 ztMK*}S2D>>^|yBvggLF8GcIVZUXG6$n2n(pgAx8^ZrqEcu^DA7Hi`4pO`Sh7(ThlA z{j>$6l6(!~yoaHX2FI;!6h2E@ zVSMbT@Lcgk;X#dTeE-JjoJ7CnKC?S+9_*~XEQ#Xkj=BeDc4ikQ`*pQohlh$GhR$YH ztAy#>QF&``^zside2W-=7Xv))foDu|g%6lTIgS0lM$ZKC01BvV>}XK3@ac#e+h|GZ z#!WMI0%i}$UkIYLZmczlw@ul9wWi;MJ>5|`Hz8fBr~c1+)eJrDP(6QYD*FQnvv8#g^TzRd0qjd%98)IUH1zuT(rBw(tcYE0~LBkuRg=9>+u)Q{B|0!~uqIU%__j)h*?;0UaO> zU`K+_S!QCQ#MQ;46YPrI7}F1kO#MrTvYfT|6ikLdPtiY4t7e+B52!00FzdA zDBJ?H!&vtbsUEuIxJ-9{CC+_9Fc{SHP)LqE6Ea_0TX*Md@hS(C)cJZ*E`}j4qk^qP zviK}V(5wLTp z+SN_1%~itf6I!pkcQ`b}<#j)EoowG%*!v(|2pCExa|a|XKzrzNdHxt>mTqm~3rkM;h=##tkS=jfv|A%>2K+Ejae z2piw>Aj0!)ksu-4zQ`X3dSwlnpDn4y(6dd4xl?*ikMoJNH2N5%c~ zA+A3nKLRf6yL|LnIEy|sK9avlk|nwu)pQ?CL>s9B`Q*x>w8XV@F&%RA@`mP)?ow^} zvD{^rx$7JN^r&d5M|z8&d}dxc+va`arSR%8%n#CcURd@N%A&{up6{= z<^TXuQ$5~@nmG!z+by1Bb3BIm&rmF|ek(WHt*MLd^(s3J>RjIwYpgya-1?2#S?~L0qbM6w6gx-Ex2LzBunt*PjN>HN&n1s3wWz zl07GZ<;zrZV8q|7#77Un6EYiSEc)~PBgx25@*z%QeT*N^>broGFYyfYcHNI|9a}MT zRFvgF3}MCdMgj!4`jeq6EGAW+%Od^)TE@Q!utXHaVj`MuuX2A!d9xUGdXuv9!p?PT z?0X8mb@nSHv` zaqC1*^cTPPx78<1AVbR942)smtWm}DO#EglZXOM1@FPEaA3Vtvas;@JC36;zg`9ao zpy^GP|m84R(&)g+KRlo0?rGoG$bw4Gx?Q{pV`Z~U*hx9)`JcLGh|mc7BblrsmB>f zc1elGokAuNApJQBZn7{A^ZxangXyUB!8Z`< zR$w}8%Sh!T28Z)@-vv)GW=Vud$vjn1i}Yt(O{b;>K@ZD?IJ|=IbtOOli@(B( zd*~UGhMs9H&V(m+rfXH~(eP(6>D{D3VRnQMw0z&*ua8t(;ZhI(?|jgHE%RKQRrb6e z5^fehTjBq)BHUuorVkYy-}0CK*V)`9+O`|w&Yjvvbpj5KSOS&{K}*Cc_E#{viSuAP z?6-s1na$SYab4q7wbp8Eg4d*cU$az)VK9W;jdL0+Z{xB`TgsF|JtUf>tybU4-x=%m z=v1P%zLZB}M}##9LjrN@4J1gRU;koxjvj>nUoCMxoOBpy3E!qd(|u2)eSG&!$@;%# zIt&ABmZp;a12l4c@K6&ayNp4Vn!fbUjn%@TMQU^3?U5h%{40`Pa7FDMPN7Tb6= zK*QML84Xq+3LlPCv=0j5Vrff(WN9y;Qt)I!zx|gE&|Dwa)fUAs-aO+a5QlO+4Fa4d z0=pOM^v3d!jn`YeT6TYr@aBAIY zP-lsKR}u3JeOBYDLu9FGc%z{;f*&`ipV-ZN)_@G=$!p?*U;9rV45U9< zFo3j8o%d5R1;kBL6ok0Kk8y~SP457CAr|)8UwLeMZrJP1FBdJv zXwsy4$Jl>O`r+I;y?4CBgTnfU@peI+67Bx$RC8*igS)?gAw>|Qi3%Sn$TIb=hAXZCskJVCdPwi(xF&2`kl88yU`WTR&2 zEjdbrSsMh9WZVTmipeLF9NQmk*J|)g=*F0PU4o3IZB)#OPh&bD$FKP{JxkIM+toe6 z8_bR3t%ZgS>ks)x5j+Cj-qt)kByNM|TMP?55$53*MNHQq|(cR*1jdLQ`v%k56QUF1Gyr(GzEc*Bv~(t-Yb4LCr4E z)d_@GujW1fXD@n2-s4%AB2+C(v8mzZ!Ev&y1v4DxXVvNDOl z_oJ_xLxypOQE_%-3G|4x9ZA?b=JLEnlbE~w`C}t(_3_-kwtcmbTCsV-4V6k}gvU~0 zmE9sFnLe`Ph|)tIJ^X|TtFO4SJJK<9u1L8>X0a5v35o7gHq4z^c`lvl<)}nLUx^N( zXXdJR={2D}cb4C<!Sjc!73B6PGaQyE@->j+^$(kADS^^OH zRH&v%xKf?8!C~V}!vg2Q&@-G0`;<)2B(nV1~x)*Y<9 zvZvulfK7LF%nXN2Rceinu|cdm!4akPgPI4`uxIYgf8ZLbOKnOXS_vqNPZXb-GH zkTj{y&?EL!dYaek4PVm2Is!YXUWXBWcCQVHU%B=vk=i z7yt1oJ%8u%Vfoy>by`(^;aJXwg&$4$?45xDGl!CnFx=7ztZBcQdh4d@;;|Fw{`$_1 z@0?4rY`Awq+W}z<^%7iKa;A78JxjtSN=uBn+Ro}6KdY4=4NkThv@6W=T<*f{5srl+ zjz_b<*q1baTcpduB=3_6zJ1ohb+f~4rUXwLoaSH%Hh!YVc#u7kT!zPby&i6F2I!4Q z66bEZ{C!1~`x{LsH}>d`1pUBTagBb0ANUmkJxeM`DaiSVqXa17c)!(mG>b08dQ7P0 z(4&dY$mjHzIf4q=KwE@kPw(>V-JXA6Pws8}D5Yb*AQ0*c%ky`TKRJ2%Y?9Aw`L+u3 zoB}QpF+-8N^jEdzH@hp3M1A)AjWdR!g@%}M+)Z;g1)gZdMz~ zUM{?MWYhHn!JWE5~It^@{@k|@elpzXyLrfm0gXeN&?o;)M2l@dT@_8SMg&OGE4&@ z8{tLhHzfi6xmS`<6#LH!pEWGgb`b4>EytlHb{(1OIVpUuKDujkn38qR4E=oIjDfe0 z=WEp{U4@S$Oi64IY=1(*`?b@J6*nrR{dC)5(X$61 ziFJeN-8!0peuFr;g838tXY1uI`AMjieumv}g7GhJ3uvx;2!%k>t@yPI;%a$t`^b^q zQ3r|w59WpLNe|tf6?|}ODBAch=KMS@aDl3(6e4Bxs%rXmCi$wl&(U-9okJO`|M}(g z!5i%-mtWi_E#QvMj&f2nFyC+w3|ly`ik%ccs_W;Tr)MlieU7vI(Ei3pt3AAA)(@80 z{=VhGQEk`l!*Nb4K2Q|R8<~LDnaenEK}oU(h$w#pZ`(h1$Kjos2TVb>{iX zuMedzjkh(};xvHZ9Vm?u4^00lHbcp?iA4|3kQDbxD12h9M#NYQUhn;B)pd-CVjm$T zB~vLFwHz=0_4dgl)7qva_Koha2d^>??13o$D{8A9w5ZS$KxeCvWK>2`WypD0e; zdaS9wa5&_Ba#D+LJtqe{Ou|+5^yecPw9Rh++f;R%_Jh&Ekr@{Y4uvp}uFj?oP!>Cx zBbB!D-0j`L37$VYk?5|iIjO}5L#5;z#tm8eX}iApU%BPgM}vZAkJ#d=|K)p%D+l6) z<{qYp=k?PfU)FQG$0rVdF_(14gHl|E<#_)_d+!2c^;n#p`!4;BPvzam`@eWK(@qiO z^(H;iHq~Z?uUcn4Hqg~5(Zh7>{8!SzgtRq;A7XgQav7U!Hw>fdsjQ_$I$%~1^vpu* zzu-jCB^?1c*hBpf&h8Fy7!&#r#SQ#*g?o@hVVwF!@&!%}U$tLu@YCK41>v2&;pA3M zaU7cHJ;Bd*WSZ-UV~Yo^vltg(_gaMeo8j(12(TZ!(R$=&yHUX|W4Ll(loiA&TTyE3 zs&J2yG_ifRRrnr=1*ar;PiCMyiPXu&6lQO>-PPF7Qs>T@c#Hy^YgAnjGo;Y>P52av zqP)5R!T8jH0`_#F9@D7rv0{5EKiQjL0vs)5MlEkrPz`US`ang%JKwRP)M%@Y97*}C zB-l|~cL*1V;LoRi@yQ4r`KTl?#XX)_#q=+JjWV@#e_`^hLCGG*k@F@dIUA)pznwElN-i~s3HS^2&)m7Kgwl`p>9^Lpiy-BNs*iSwD%acwWTMs{O1@XyBcC@TxmIR*~hwghVSApjtH|ixqf1Yw&pQrrl8q?3YviwmuxS-MFW}cJSN=f7n(;G=_G03 zI2S@-63=ZrNiM2Y?wKJAZyrfw`S+sd9)kJ$Xuaq!`6qC>>f5KwPvxlZ9pmbXW+Bdr zpu?v{zU-?TiTSU*cWmu4bCXDqceFM45e`MFqkc+H!+O2xYHVOkvV0Afo9iuqf8c?D znVpZ1YSrg=g}om<*OYagXk!{^IU?B3FwD*%mhIm8-n%WL}IQ`v-J~Faqn#6XK#jopg4N~B^XN4b^*mg0xl3MS{4diw{?S0pyrjC1; zw*%i)y!@@31+I1HVsia#R$Bg?)br`Kgluz8Bwy_iktxZ`D1U)jrt|P%r^$7<_pqfB z)gn{L3-(Q!p1WJ&q}^BcClCRY?`=fnV786EzvYnJAak+$nmg;;Fbcn5m@$>0A7EJO z2{T_ceIyAxQWyQ^bcPR5MfdNXYp5;7X;~~B$uNTkPX)-TI61Ih#ip-re_U02?LOhy z$0PSd+lRTl`Ncnpuh%VFI0Y1oMSoOOU*FnwH#2kLj|ucZHw?0WK$$CSSA`1UZuhC0B9C9RQm6!)yHB?WcBD7uVt7i{fIkgjbf9V9> zB-67z?9Y-)uW5b3pYpFB*2yOZ!KqZLc2=$!Vd)g}?9F@bqvWK>xV4-+n7zz*`tMrH zZbHw>{sG{gZQHZ&!S79<|5ljQaDV&Jd2YI4GZexi*7Z<(CoQ!?V5m=KGJ=3 ztcNL~qlJzNR4d-^>S=4vNXH5ULcyea8rJI#C@IVyD#4~MHT2y2_(J;UKaKiWae7At z1IP&wJ->9E6jRKBtEb3~?4f7$JT>=^gt)&EI(OK?;CEXuC$*RE(NB`)k|=bs;)Gw=!wbc0J^@<* zJM8E*8xw#>!sq>z83z$S*@dIGgoxVrZTOU-pu4s87c$mP9g%E1B6iM@G>>s%Zm%aT z{AG#X2dC0pZtq%Ibt`?l`j1A_Ii{A;d9!11K zy4RS3dB7}ym!+TMHHsAH5sTkFm1Ik>5(aLL4i@@ zpD*MeRw@am;P5P+8iZ|?Er%`gD}NjLvYvaeVWEx}dWO#O;V$=BZW zG_Tj2mWI+u#|fLK4~}#lzs2k2Br64kk+Iq3NSt}_T(g9^qw~F{h@981qY}J`$Tr!z zU{vTFeXM4!6=%DIvxl@n_K({j*p4tibTs2~)d6nGsnn%!#Z7zpKo-10BY?z(pf zWeG5Ogi!atd?lS8KJ9Jl&Wh6u-V>RTOXiIMa3jY}7l&uER}-g$syxg_FW5>y&`LjS z`q+qRW20t_j+-$m#oQ#r!Z^>$xX{WZ!+UJR+@VQMdc_OJlg1RF`&17Sf*Y-v!FCC1 ztDeaA?)fSa)3LaYJL;BrknilJNI!2(UJrLIkFjDokIwQoj

H&=zolgxDm)tn$z@OP$)jn&lZ(+vwKfYg{nKxs|5yI`^RM*{x6{2Q1Mo!*SC+?s;>G%#ZN{vh zF>al;5!hJ;?vpYcO#NmIh;%YcbTc9H3+*%}vlIDik?z3SlAkDSCH)kEFG8#(_#&7i z+O&@^?}_$(g_!Q#AO~$HrdZtU(d;v-!Yn1?ho2U?sXg>8m|pYU>pM4+G&$17Aau6g z=9!}wzM~iIGCtX7O6G#Mh+P5gNp0zAP9SK%xtqB03+6{W zSy+|?gI1MpTm3&^aYx!2B|A>e_BIH$8hESNkJhp)vU9#benu*W)kqsn(;E9GS{mgsGm>}nQeXOQVTK6{>7;H-g(3x5m58PmqZNnFk@Mv6VpQVteQ}NyY zmG6Mv4aFc&VIz>_NeG*em9KK(KDq4ay=#>9Tnq&xcq`Q$d5GE&+Livwv+aELeO=St z?aO{tNVt>R#CT8rj76h@tVVDMiuD;o+;NG|gmhc|2#X;=5G1=8r`hXovYosu)&l@e znuijM`gBo7 zWfbcL{WH8mNE`i+kMtE_c_J+c2BTY9cBtP)NR-{{Ip79cEAqemm@n9y>rrA$eeScv z?5jLZSjV)ggQ<&FexegJb5QYTuOvE7pvI9y#Bp?-vspY*U2bE5sa)qUbd!s2ke5-| zyipOpqe2AYf$j$Tq1mn@Go4MMW)DlSHNtt7kaL_#2>!}&(Z}kS?l_dNngAwb_ia9uCysDM0H@KS$T;vQ>$rIxBlomCx$LVuw&G-hj9r7} zkSjHkqj$ez?AO+vd@K32Uh^==-6V6mBFtvwvKcQ0dl-gW58G{}i1gG0vnXZGz;r8e zcMc7nH6Y*4#sLCo&-H}^gppZZY^=&cKR!< zf71Nm2-%T1_={~`(9_q(P;TDS-V3k~dHd<8y_C29L%-<*gFaQ@(G=r3CCp)bsEt{? z^H}nN75h#~w>ONQ_R^6^ORe@c8Y(;?0d*GlW_##g;oE}d8#dKVPHL^H_V$%@tC%^8 z(78I{){}ugOSVx2SpA4i6YYN$TMcvHUy-1~1-)}^^}fu7zaWYn@BPj1D}p{!gnp`s zo~ekNt%#+XD`LzQ*;5BlGp7#9m^L_b+R)7D!!u{CjA{pFph_JcOS z@STQoJZT1Y}9J6*`0Fy+zGALvT=0`s>`c|6IOLAFrBr zGAcfXX^1f@*C_9uIk=bfJC z$olf5B;Vhs`20`7;y>pve?N86pCf&K7xvj7(l^aIp1-#G(l%}Nm2bR%uL}rzLNsFk zXvdt~aJyvl)b+ClMY#@LJ!im;L;lV6j|GXbC>rZDtt!Ov{tK&?9ia_db8YRdGY6BR zS5KQaeOwqQF%F7C-=Rgm!^xKDH+Oj4;$Q5Jx9R^ry}ywMMB7#g@2EjqfIZY4UpWJw zHZICZpR7zG*O>iKWG!vQ{>LhTWg!7s^uCY$cdy~?QGb=q+1po6-@J74`i0|H z&mFyT_Q>Tkhp%0DQm(wJ6LNB9UCY!0XhXfoGW7yvY?ZQROe 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 literal 0 HcmV?d00001 diff --git a/Images/P25_sm.bmp b/Images/P25_sm.bmp new file mode 100644 index 0000000000000000000000000000000000000000..938e83a90acdeaa4e09aa167f4e2171cbfbdfbe4 GIT binary patch literal 50454 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 literal 0 HcmV?d00001 diff --git a/Images/Tetra_sm.bmp b/Images/Tetra_sm.bmp new file mode 100644 index 0000000000000000000000000000000000000000..846d7ef61f51fde6d83abd92409a655255608d14 GIT binary patch literal 37974 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 literal 0 HcmV?d00001 diff --git a/Images/dPMR.bmp b/Images/dPMR.bmp new file mode 100644 index 0000000000000000000000000000000000000000..85da5d06abb2984ec1dcd4d1701893c2636be56e GIT binary patch literal 151970 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 +#include + +CLC::CLC(FLCO flco, unsigned int srcId, unsigned int dstId) : +m_PF(false), +m_FLCO(flco), +m_FID(0U), +m_srcId(srcId), +m_dstId(dstId) +{ +} + +CLC::CLC(const unsigned char* bytes) : +m_PF(false), +m_FLCO(FLCO_GROUP), +m_FID(0U), +m_srcId(0U), +m_dstId(0U) +{ + assert(bytes != NULL); + + m_PF = (bytes[0U] & 0x80U) == 0x80U; + + m_FLCO = FLCO(bytes[0U] & 0x3FU); + + m_FID = bytes[1U]; + + m_dstId = bytes[3U] << 16 | bytes[4U] << 8 | bytes[5U]; + m_srcId = bytes[6U] << 16 | bytes[7U] << 8 | bytes[8U]; +} + +CLC::CLC(const bool* bits) : +m_PF(false), +m_FLCO(FLCO_GROUP), +m_FID(0U), +m_srcId(0U), +m_dstId(0U) +{ + assert(bits != NULL); + + m_PF = bits[0U]; + + unsigned char temp1, temp2; + CUtils::bitsToByteBE(bits + 0U, temp1); + m_FLCO = FLCO(temp1 & 0x3FU); + + CUtils::bitsToByteBE(bits + 8U, temp2); + m_FID = temp2; + + unsigned char d1, d2, d3; + CUtils::bitsToByteBE(bits + 24U, d1); + CUtils::bitsToByteBE(bits + 32U, d2); + CUtils::bitsToByteBE(bits + 40U, d3); + + unsigned char s1, s2, s3; + CUtils::bitsToByteBE(bits + 48U, s1); + CUtils::bitsToByteBE(bits + 56U, s2); + CUtils::bitsToByteBE(bits + 64U, s3); + + m_srcId = s1 << 16 | s2 << 8 | s3; + m_dstId = d1 << 16 | d2 << 8 | d3; +} + +CLC::CLC() : +m_PF(false), +m_FLCO(FLCO_GROUP), +m_FID(0U), +m_srcId(0U), +m_dstId(0U) +{ +} + +CLC::~CLC() +{ +} + +void CLC::getData(unsigned char* bytes) const +{ + assert(bytes != NULL); + + bytes[0U] = (unsigned char)m_FLCO; + + if (m_PF) + bytes[0U] |= 0x80U; + + bytes[1U] = m_FID; + + bytes[3U] = m_dstId >> 16; + bytes[4U] = m_dstId >> 8; + bytes[5U] = m_dstId >> 0; + + bytes[6U] = m_srcId >> 16; + bytes[7U] = m_srcId >> 8; + bytes[8U] = m_srcId >> 0; +} + +void CLC::getData(bool* bits) const +{ + unsigned char bytes[9U]; + getData(bytes); + + CUtils::byteToBitsBE(bytes[0U], bits + 0U); + CUtils::byteToBitsBE(bytes[1U], bits + 8U); + CUtils::byteToBitsBE(bytes[2U], bits + 16U); + CUtils::byteToBitsBE(bytes[3U], bits + 24U); + CUtils::byteToBitsBE(bytes[4U], bits + 32U); + CUtils::byteToBitsBE(bytes[5U], bits + 40U); + CUtils::byteToBitsBE(bytes[6U], bits + 48U); + CUtils::byteToBitsBE(bytes[7U], bits + 56U); + CUtils::byteToBitsBE(bytes[8U], bits + 64U); +} + +bool CLC::getPF() const +{ + return m_PF; +} + +void CLC::setPF(bool pf) +{ + m_PF = pf; +} + +FLCO CLC::getFLCO() const +{ + return m_FLCO; +} + +void CLC::setFLCO(FLCO flco) +{ + m_FLCO = flco; +} + +unsigned char CLC::getFID() const +{ + return m_FID; +} + +void CLC::setFID(unsigned char fid) +{ + m_FID = fid; +} + +unsigned int CLC::getSrcId() const +{ + return m_srcId; +} + +void CLC::setSrcId(unsigned int id) +{ + m_srcId = id; +} + +unsigned int CLC::getDstId() const +{ + return m_dstId; +} + +void CLC::setDstId(unsigned int id) +{ + m_dstId = id; +} diff --git a/LC.h b/LC.h new file mode 100644 index 0000000..ca31914 --- /dev/null +++ b/LC.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(LC_H) +#define LC_H + +#include "DMRDefines.h" + +class CLC +{ +public: + CLC(FLCO flco, unsigned int srcId, unsigned int dstId); + CLC(const unsigned char* bytes); + CLC(const bool* bits); + CLC(); + ~CLC(); + + void getData(unsigned char* bytes) const; + void getData(bool* bits) const; + + bool getPF() const; + void setPF(bool pf); + + FLCO getFLCO() const; + void setFLCO(FLCO flco); + + unsigned char getFID() const; + void setFID(unsigned char fid); + + unsigned int getSrcId() const; + void setSrcId(unsigned int id); + + unsigned int getDstId() const; + void setDstId(unsigned int id); + +private: + bool m_PF; + FLCO m_FLCO; + unsigned char m_FID; + unsigned int m_srcId; + unsigned int m_dstId; +}; + +#endif + diff --git a/LICENCE b/LICENCE new file mode 100644 index 0000000..3912109 --- /dev/null +++ b/LICENCE @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/Log.cpp b/Log.cpp new file mode 100644 index 0000000..19a6198 --- /dev/null +++ b/Log.cpp @@ -0,0 +1,127 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "Log.h" + +#include +#include +#include +#include +#include + +static std::string m_path; +static std::string m_root; + +static FILE* m_fpLog = NULL; + +static bool m_display = true; + +static unsigned int m_level = 2U; + +static struct tm m_tm; + +static char LEVELS[] = " DMIWEF"; + +static bool LogOpen() +{ + time_t now; + ::time(&now); + + struct tm* tm = ::gmtime(&now); + + if (tm->tm_mday == m_tm.tm_mday && tm->tm_mon == m_tm.tm_mon && tm->tm_year == m_tm.tm_year) { + if (m_fpLog != NULL) + return true; + } else { + if (m_fpLog != NULL) + ::fclose(m_fpLog); + } + + char filename[50U]; +#if defined(WIN32) + ::sprintf(filename, "%s\\%s-%04d-%02d-%02d.log", m_path.c_str(), m_root.c_str(), tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday); +#else + ::sprintf(filename, "%s/%s-%04d-%02d-%02d.log", m_path.c_str(), m_root.c_str(), tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday); +#endif + + m_fpLog = ::fopen(filename, "a+t"); + m_tm = *tm; + + return m_fpLog != NULL; +} + +bool LogInitialise(const std::string& path, const std::string& root, bool display) +{ + m_path = path; + m_root = root; + m_display = display; + return ::LogOpen(); +} + +void LogFinalise() +{ + if (m_fpLog != NULL) + ::fclose(m_fpLog); +} + +void LogSetLevel(unsigned int level) +{ + m_level = level; +} + +void Log(unsigned int level, const char* fmt, ...) +{ + assert(level < 7U); + assert(fmt != NULL); + + if (level < m_level) + return; + + bool ret = ::LogOpen(); + if (!ret) + return; + + time_t now; + ::time(&now); + + struct tm* tm = ::gmtime(&now); + + ::fprintf(m_fpLog, "%c: %04d-%02d-%02d %02d:%02d:%02d ", LEVELS[level], tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); + if (m_display) + ::fprintf(stdout, "%c: %04d-%02d-%02d %02d:%02d:%02d ", LEVELS[level], tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); + + va_list vl; + va_start(vl, fmt); + vfprintf(m_fpLog, fmt, vl); + if (m_display) + vfprintf(stdout, fmt, vl); + va_end(vl); + + ::fprintf(m_fpLog, "\n"); + ::fflush(m_fpLog); + + if (m_display) { + ::fprintf(stdout, "\n"); + ::fflush(stdout); + } + + if (level == 6U) { // Fatal + ::fclose(m_fpLog); + exit(1); + } +} diff --git a/Log.h b/Log.h new file mode 100644 index 0000000..a1dc869 --- /dev/null +++ b/Log.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(LOG_H) +#define LOG_H + +#include + +#define LogDebug(fmt, ...) Log(1U, fmt, ##__VA_ARGS__) +#define LogMessage(fmt, ...) Log(2U, fmt, ##__VA_ARGS__) +#define LogInfo(fmt, ...) Log(3U, fmt, ##__VA_ARGS__) +#define LogWarning(fmt, ...) Log(4U, fmt, ##__VA_ARGS__) +#define LogError(fmt, ...) Log(5U, fmt, ##__VA_ARGS__) +#define LogFatal(fmt, ...) Log(6U, fmt, ##__VA_ARGS__) + +extern void Log(unsigned int level, const char* fmt, ...); + +extern bool LogInitialise(const std::string& path, const std::string& root, bool display); +extern void LogFinalise(); + +extern void LogSetLevel(unsigned int level); + +#endif diff --git a/MMDVM.ini b/MMDVM.ini new file mode 100644 index 0000000..21e3220 --- /dev/null +++ b/MMDVM.ini @@ -0,0 +1,70 @@ +[General] +Callsign=G9BF +Timeout=120 +Duplex=1 +ModeHang=10 +Display=None + +[Info] +RXFrequency=435000000 +TXFrequency=435000000 +Power=1 +Latitude=51.0 +Longitude=-1.0 +Height=0 +Location=Nowhere +Description=Multi-Mode Repeater +URL=www.google.co.uk + +[Log] +# Logging levels, 0=No logging +Level=1 +Path=. +Root=MMDVM +Display=1 + +[Modem] +# Port=/dev/ttyACM0 +Port=\\.\COM3 +TXInvert=1 +RXInvert=0 +PTTInvert=0 +TXDelay=100 +RXLevel=50 +TXLevel=50 +Debug=0 + +[D-Star] +Enable=1 +Module=C + +[DMR] +Enable=1 +Id=123456 +ColorCode=1 + +[System Fusion] +Enable=1 + +[D-Star Network] +Enable=1 +GatewayAddress=127.0.0.1 +GatewayPort=20010 +LocalPort=20011 +Debug=0 + +[DMR Network] +Enable=1 +Address=44.131.4.1 +Port=62031 +Password=PASSWORD +Debug=1 + +[System Fusion Network] +Enable=0 +Address=44.131.4.1 +Port=32768 +Debug=1 + +[TFT Serial] +Port=/dev/ttyAMA0 diff --git a/MMDVMHost.cpp b/MMDVMHost.cpp new file mode 100644 index 0000000..b21c1f4 --- /dev/null +++ b/MMDVMHost.cpp @@ -0,0 +1,473 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "MMDVMHost.h" +#include "Log.h" +#include "Version.h" +#include "StopWatch.h" +#include "Defines.h" +#include "DMRControl.h" +#include "TFTSerial.h" +#include "NullDisplay.h" + +#include "DStarEcho.h" +#include "YSFEcho.h" + +#include + +#if !defined(WIN32) +#include +#include +#endif + +static bool m_killed = false; + +#if !defined(WIN32) +static void sigHandler(int) +{ + m_killed = true; +} +#endif + +const char* HEADER1 = "This software is for use on amateur radio networks only."; +const char* HEADER2 = "Its use on commercial networks is strictly prohibited."; +const char* HEADER3 = "Copyright(C) 2015, 2016 by Jonathan Naylor, G4KLX"; + +int main(int argc, char** argv) +{ + if (argc == 1) { + ::fprintf(stderr, "Usage: MMDVMHost \n"); + return 1; + } + +#if !defined(WIN32) + ::signal(SIGUSR1, sigHandler); +#endif + + CMMDVMHost* host = new CMMDVMHost(std::string(argv[1])); + int ret2 = host->run(); + + delete host; + + ::LogFinalise(); + + return ret2; +} + +CMMDVMHost::CMMDVMHost(const std::string& confFile) : +m_conf(confFile), +m_modem(NULL), +m_dmrNetwork(NULL), +m_display(NULL), +m_dstarEnabled(false), +m_dmrEnabled(false), +m_ysfEnabled(false) +{ +} + +CMMDVMHost::~CMMDVMHost() +{ +} + +int CMMDVMHost::run() +{ + bool ret = m_conf.read(); + if (!ret) { + ::fprintf(stderr, "MMDVMHost: cannot read the .ini file\n"); + return 1; + } + + ret = ::LogInitialise(m_conf.getLogPath(), m_conf.getLogRoot(), m_conf.getLogDisplay()); + if (!ret) { + ::fprintf(stderr, "MMDVMHost: unable to open the log file\n"); + return 1; + } + + ::LogSetLevel(m_conf.getLogLevel()); + + LogInfo(HEADER1); + LogInfo(HEADER2); + LogInfo(HEADER3); + + LogMessage("MMDVMHost-%s is starting", VERSION); + + readParams(); + + ret = createModem(); + if (!ret) + return 1; + + createDisplay(); + + if (m_dmrEnabled) { + ret = createDMRNetwork(); + if (!ret) + return 1; + } + + CStopWatch stopWatch; + stopWatch.start(); + + CDStarEcho* dstar = NULL; + if (m_dstarEnabled) + dstar = new CDStarEcho(2U, 10000U); + + CDMRControl* dmr = NULL; + if (m_dmrEnabled) { + unsigned int id = m_conf.getDMRId(); + unsigned int colorCode = m_conf.getDMRColorCode(); + unsigned int timeout = m_conf.getTimeout(); + + LogInfo("DMR Parameters"); + LogInfo(" Id: %u", id); + LogInfo(" Color Code: %u", colorCode); + LogInfo(" Timeout: %us", timeout); + + dmr = new CDMRControl(id, colorCode, timeout, m_modem, m_dmrNetwork, m_display); + } + + CYSFEcho* ysf = NULL; + if (m_ysfEnabled) + ysf = new CYSFEcho(2U, 10000U); + + unsigned char mode = MODE_IDLE; + CTimer modeTimer(1000U, m_conf.getModeHang()); + + m_display->setIdle(); + + while (!m_killed) { + unsigned char data[200U]; + unsigned int len; + bool ret; + + len = m_modem->readDStarData(data); + if (dstar != NULL && len > 0U) { + if (mode == MODE_IDLE && (data[0U] == TAG_HEADER || data[0U] == TAG_DATA)) { + LogMessage("Mode set to D-Star"); + mode = MODE_DSTAR; + m_display->setDStar(); + m_modem->setMode(MODE_DSTAR); + modeTimer.start(); + } + if (mode != MODE_DSTAR) { + LogWarning("D-Star data received when in mode %u", mode); + } else { + if (data[0U] == TAG_HEADER || data[0U] == TAG_DATA || data[0U] == TAG_EOT) { + dstar->writeData(data, len); + modeTimer.start(); + } + } + } + + len = m_modem->readDMRData1(data); + if (dmr != NULL && len > 0U) { + if (mode == MODE_IDLE) { + bool ret = dmr->processWakeup(data); + if (ret) { + LogMessage("Mode set to DMR"); + mode = MODE_DMR; + m_display->setDMR(); + // This sets the mode to DMR within the modem + m_modem->writeDMRStart(true); + modeTimer.start(); + } + } else if (mode == MODE_DMR) { + dmr->writeModemSlot1(data); + modeTimer.start(); + } else { + LogWarning("DMR data received when in mode %u", mode); + } + } + + len = m_modem->readDMRData2(data); + if (dmr != NULL && len > 0U) { + if (mode == MODE_IDLE) { + bool ret = dmr->processWakeup(data); + if (ret) { + LogMessage("Mode set to DMR"); + mode = MODE_DMR; + m_display->setDMR(); + // This sets the mode to DMR within the modem + m_modem->writeDMRStart(true); + modeTimer.start(); + } + } else if (mode == MODE_DMR) { + dmr->writeModemSlot2(data); + modeTimer.start(); + } else { + LogWarning("DMR data received when in mode %u", mode); + } + } + + len = m_modem->readYSFData(data); + if (ysf != NULL && len > 0U) { + if (mode == MODE_IDLE && data[0U] == TAG_DATA) { + LogMessage("Mode set to System Fusion"); + mode = MODE_YSF; + m_display->setFusion(); + m_modem->setMode(MODE_YSF); + modeTimer.start(); + } + if (mode != MODE_YSF) { + LogWarning("System Fusion data received when in mode %u", mode); + } else { + if (data[0U] == TAG_DATA) { + data[1U] = 0x00U; // FICH digest + ysf->writeData(data, len); + modeTimer.start(); + } + } + } + + if (modeTimer.isRunning() && modeTimer.hasExpired()) { + LogMessage("Mode set to Idle"); + + if (mode == MODE_DMR) + m_modem->writeDMRStart(false); + + mode = MODE_IDLE; + m_display->setIdle(); + m_modem->setMode(MODE_IDLE); + modeTimer.stop(); + } + + if (dstar != NULL) { + ret = dstar->hasData(); + if (ret) { + ret = m_modem->hasDStarSpace(); + if (ret) { + len = dstar->readData(data); + if (mode != MODE_DSTAR) { + LogWarning("D-Star echo data received when in mode %u", mode); + } else { + m_modem->writeDStarData(data, len); + modeTimer.start(); + } + } + } + } + + if (dmr != NULL) { + ret = m_modem->hasDMRSpace1(); + if (ret) { + len = dmr->readModemSlot1(data); + if (len > 0U && mode == MODE_IDLE) { + m_display->setDMR(); + mode = MODE_DMR; + } + if (len > 0U && mode == MODE_DMR) { + m_modem->writeDMRData1(data, len); + modeTimer.start(); + } + } + + ret = m_modem->hasDMRSpace2(); + if (ret) { + len = dmr->readModemSlot2(data); + if (len > 0U && mode == MODE_IDLE) { + m_display->setDMR(); + mode = MODE_DMR; + } + if (len > 0U && mode == MODE_DMR) { + m_modem->writeDMRData2(data, len); + modeTimer.start(); + } + } + } + + if (ysf != NULL) { + ret = ysf->hasData(); + if (ret) { + ret = m_modem->hasYSFSpace(); + if (ret) { + len = ysf->readData(data); + if (mode != MODE_YSF) { + LogWarning("System Fusion echo data received when in mode %u", mode); + } else { + m_modem->writeYSFData(data, len); + modeTimer.start(); + } + } + } + } + + unsigned int ms = stopWatch.elapsed(); + m_modem->clock(ms); + modeTimer.clock(ms); + if (dstar != NULL) + dstar->clock(ms); + if (dmr != NULL) + dmr->clock(ms); + if (ysf != NULL) + ysf->clock(ms); + stopWatch.start(); + + if (ms < 5U) { +#if defined(WIN32) + ::Sleep(5UL); // 5ms +#else + ::usleep(5000); // 5ms +#endif + } + } + + LogMessage("MMDVMHost is exiting on receipt of SIGHUP1"); + + m_display->setIdle(); + + m_modem->close(); + delete m_modem; + + m_display->close(); + delete m_display; + + if (m_dmrNetwork != NULL) { + m_dmrNetwork->close(); + delete m_dmrNetwork; + } + + delete dstar; + delete dmr; + delete ysf; + + return 0; +} + +bool CMMDVMHost::createModem() +{ + std::string port = m_conf.getModemPort(); + bool rxInvert = m_conf.getModemRXInvert(); + bool txInvert = m_conf.getModemTXInvert(); + bool pttInvert = m_conf.getModemPTTInvert(); + unsigned int txDelay = m_conf.getModemTXDelay(); + unsigned int rxLevel = m_conf.getModemRXLevel(); + unsigned int txLevel = m_conf.getModemTXLevel(); + bool debug = m_conf.getModemDebug(); + unsigned int colorCode = m_conf.getDMRColorCode(); + + LogInfo("Modem Parameters"); + LogInfo(" Port: %s", port.c_str()); + LogInfo(" RX Invert: %s", rxInvert ? "yes" : "no"); + LogInfo(" TX Invert: %s", txInvert ? "yes" : "no"); + LogInfo(" PTT Invert: %s", pttInvert ? "yes" : "no"); + LogInfo(" TX Delay: %u", txDelay); + LogInfo(" RX Level: %u", rxLevel); + LogInfo(" TX Level: %u", txLevel); + + m_modem = new CModem(port, rxInvert, txInvert, pttInvert, txDelay, rxLevel, txLevel, debug); + m_modem->setModeParams(m_dstarEnabled, m_dmrEnabled, m_ysfEnabled); + m_modem->setDMRParams(colorCode); + + bool ret = m_modem->open(); + if (!ret) { + delete m_modem; + m_modem = NULL; + return false; + } + + return true; +} + +bool CMMDVMHost::createDMRNetwork() +{ + if (!m_conf.getDMRNetworkEnabled()) + return false; + + std::string address = m_conf.getDMRNetworkAddress(); + unsigned int port = m_conf.getDMRNetworkPort(); + unsigned int id = m_conf.getDMRId(); + std::string password = m_conf.getDMRNetworkPassword(); + bool debug = m_conf.getDMRNetworkDebug(); + + LogInfo("DMR Network Parameters"); + LogInfo(" Address: %s", address.c_str()); + LogInfo(" Port: %u", port); + + m_dmrNetwork = new CHomebrewDMRIPSC(address, port, id, password, VERSION, "MMDVMHost", debug); + + std::string callsign = m_conf.getCallsign(); + unsigned int rxFrequency = m_conf.getRxFrequency(); + unsigned int txFrequency = m_conf.getTxFrequency(); + unsigned int power = m_conf.getPower(); + unsigned int colorCode = m_conf.getDMRColorCode(); + float latitude = m_conf.getLatitude(); + float longitude = m_conf.getLongitude(); + int height = m_conf.getHeight(); + std::string location = m_conf.getLocation(); + std::string description = m_conf.getDescription(); + std::string url = m_conf.getURL(); + + LogInfo("Info Parameters"); + LogInfo(" Callsign: %s", callsign.c_str()); + LogInfo(" RX Frequency: %uHz", rxFrequency); + LogInfo(" TX Frequency: %uHz", txFrequency); + LogInfo(" Power: %uW", power); + LogInfo(" Latitude: %fdeg N", latitude); + LogInfo(" Longitude: %fdeg E", longitude); + LogInfo(" Height: %um", height); + LogInfo(" Location: \"%s\"", location.c_str()); + LogInfo(" Description: \"%s\"", description.c_str()); + LogInfo(" URL: \"%s\"", url.c_str()); + + m_dmrNetwork->setConfig(callsign, rxFrequency, txFrequency, power, colorCode, latitude, longitude, height, location, description, url); + + bool ret = m_dmrNetwork->open(); + if (!ret) { + delete m_dmrNetwork; + m_dmrNetwork = NULL; + return false; + } + + return true; +} + +void CMMDVMHost::readParams() +{ + m_dstarEnabled = m_conf.getDStarEnabled(); + m_dmrEnabled = m_conf.getDMREnabled(); + m_ysfEnabled = m_conf.getFusionEnabled(); + + if (!m_conf.getDuplex() && m_dmrEnabled) { + LogWarning("DMR operation disabled because system is not duplex"); + m_dmrEnabled = false; + } +} + +void CMMDVMHost::createDisplay() +{ + std::string type = m_conf.getDisplay(); + + LogInfo("Display Parameters"); + LogInfo(" Type: %s", type.c_str()); + + if (type == "TFT Serial") { + std::string port = m_conf.getTFTSerialPort(); + + LogInfo(" Port: %s", port.c_str()); + + m_display = new CTFTSerial(port); + } else { + m_display = new CNullDisplay; + } + + bool ret = m_display->open(); + if (!ret) { + delete m_display; + m_display = new CNullDisplay; + } +} diff --git a/MMDVMHost.h b/MMDVMHost.h new file mode 100644 index 0000000..3e9e2b8 --- /dev/null +++ b/MMDVMHost.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(MMDVMHOST_H) +#define MMDVMHOST_H + +#include "HomebrewDMRIPSC.h" +#include "Display.h" +#include "Modem.h" +#include "Conf.h" + +#include + +class CMMDVMHost +{ +public: + CMMDVMHost(const std::string& confFile); + ~CMMDVMHost(); + + int run(); + +private: + CConf m_conf; + CModem* m_modem; + CHomebrewDMRIPSC* m_dmrNetwork; + IDisplay* m_display; + bool m_dstarEnabled; + bool m_dmrEnabled; + bool m_ysfEnabled; + + void readParams(); + bool createModem(); + bool createDMRNetwork(); + void createDisplay(); +}; + +#endif diff --git a/MMDVMHost.sln b/MMDVMHost.sln new file mode 100644 index 0000000..b130c28 --- /dev/null +++ b/MMDVMHost.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.24720.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MMDVMHost", "MMDVMHost.vcxproj", "{1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Debug|x64.ActiveCfg = Debug|x64 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Debug|x64.Build.0 = Debug|x64 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Debug|x86.ActiveCfg = Debug|Win32 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Debug|x86.Build.0 = Debug|Win32 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Release|x64.ActiveCfg = Release|x64 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Release|x64.Build.0 = Release|x64 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Release|x86.ActiveCfg = Release|Win32 + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/MMDVMHost.vcxproj b/MMDVMHost.vcxproj new file mode 100644 index 0000000..0eecefa --- /dev/null +++ b/MMDVMHost.vcxproj @@ -0,0 +1,228 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + {1D34E8C1-CFA5-4D60-B509-9DB58DC4AE92} + Win32Proj + MMDVMHost + 8.1 + + + + Application + true + v140 + Unicode + + + Application + false + v140 + true + Unicode + + + Application + true + v140 + Unicode + + + Application + false + v140 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + + + Console + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;ws2_32.lib;%(AdditionalDependencies) + + + + + + + Level3 + Disabled + _DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + + + Console + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;ws2_32.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + + + Console + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;ws2_32.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + + + Console + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;ws2_32.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MMDVMHost.vcxproj.filters b/MMDVMHost.vcxproj.filters new file mode 100644 index 0000000..3a21235 --- /dev/null +++ b/MMDVMHost.vcxproj.filters @@ -0,0 +1,236 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..bbeb58d --- /dev/null +++ b/Makefile @@ -0,0 +1,120 @@ +CC = g++ +CFLAGS = -O2 -Wall -std=c++11 +LIBS = +LDFLAGS = + +all: MMDVMHost + +MMDVMHost: BPTC19696.o Conf.o CRC.o CSBK.o Display.o DMRControl.o DMRData.o DMRSlot.o DMRSync.o DStarEcho.o EMB.o EmbeddedLC.o FullLC.o Golay2087.o Golay24128.o \ + Hamming.o HomebrewDMRIPSC.o LC.o Log.o MMDVMHost.o Modem.o NullDisplay.o QR1676.o RS129.o SerialController.o SHA256.o ShortLC.o SlotType.o StopWatch.o \ + TFTSerial.o Timer.o UDPSocket.o Utils.o YSFEcho.o + $(CC) $(LDFLAGS) -o MMDVMHost BPTC19696.o Conf.o CRC.o CSBK.o Display.o DMRControl.o DMRData.o DMRSlot.o DMRSync.o DStarEcho.o EMB.o EmbeddedLC.o FullLC.o \ + Golay2087.o Golay24128.o Hamming.o HomebrewDMRIPSC.o LC.o Log.o MMDVMHost.o Modem.o NullDisplay.o QR1676.o RS129.o SerialController.o SHA256.o ShortLC.o \ + SlotType.o StopWatch.o TFTSerial.o Timer.o UDPSocket.o Utils.o YSFEcho.o $(LIBS) + +BPTC19696.o: BPTC19696.cpp BPTC19696.h Utils.h Hamming.h + $(CC) $(CFLAGS) -c BPTC19696.cpp + +Conf.o: Conf.cpp Conf.h Log.h + $(CC) $(CFLAGS) -c Conf.cpp + +CRC.o: CRC.cpp CRC.h Utils.h + $(CC) $(CFLAGS) -c CRC.cpp + +CSBK.o: CSBK.cpp CSBK.h Utils.h DMRDefines.h BPTC19696.h CRC.h Log.h + $(CC) $(CFLAGS) -c CSBK.cpp + +Display.o: Display.cpp Display.h + $(CC) $(CFLAGS) -c Display.cpp + +DMRControl.o: DMRControl.cpp DMRControl.h DMRSlot.h DMRData.h Modem.h HomebrewDMRIPSC.h Defines.h CSBK.h Log.h DIsplay.h + $(CC) $(CFLAGS) -c DMRControl.cpp + +DMRData.o: DMRData.cpp DMRData.h DMRDefines.h Utils.h Log.h + $(CC) $(CFLAGS) -c DMRData.cpp + +DMRSlot.o: DMRSlot.cpp DMRSlot.h DMRData.h Modem.h HomebrewDMRIPSC.h Defines.h Log.h EmbeddedLC.h RingBuffer.h Timer.h LC.h SlotType.h DMRSync.h FullLC.h \ + EMB.h CRC.h CSBK.h ShortLC.h Utils.h Display.h + $(CC) $(CFLAGS) -c DMRSlot.cpp + +DMRSync.o: DMRSync.cpp DMRSync.h DMRDefines.h + $(CC) $(CFLAGS) -c DMRSync.cpp + +DStarEcho.o: DStarEcho.cpp DStarEcho.h RingBuffer.h Timer.h + $(CC) $(CFLAGS) -c DStarEcho.cpp + +EMB.o: EMB.cpp EMB.h + $(CC) $(CFLAGS) -c EMB.cpp + +EmbeddedLC.o: EmbeddedLC.cpp EmbeddedLC.h CRC.h Utils.h LC.h Hamming.h Log.h + $(CC) $(CFLAGS) -c EmbeddedLC.cpp + +FullLC.o: FullLC.cpp FullLC.h BPTC19696.h LC.h SlotType.h Log.h DMRDefines.h RS129.h + $(CC) $(CFLAGS) -c FullLC.cpp + +Golay2087.o: Golay2087.cpp Golay2087.h + $(CC) $(CFLAGS) -c Golay2087.cpp + +Golay24128.o: Golay24128.cpp Golay24128.h + $(CC) $(CFLAGS) -c Golay24128.cpp + +Hamming.o: Hamming.cpp Hamming.h + $(CC) $(CFLAGS) -c Hamming.cpp + +HomebrewDMRIPSC.o: HomebrewDMRIPSC.cpp HomebrewDMRIPSC.h Log.h UDPSocket.h Timer.h DMRData.h RingBuffer.h Utils.h SHA256.h StopWatch.h + $(CC) $(CFLAGS) -c HomebrewDMRIPSC.cpp + +LC.o: LC.cpp LC.h Utils.h DMRDefines.h + $(CC) $(CFLAGS) -c LC.cpp + +Log.o: Log.cpp Log.h + $(CC) $(CFLAGS) -c Log.cpp + +MMDVMHost.o: MMDVMHost.cpp MMDVMHost.h Conf.h Log.h Version.h Modem.h StopWatch.h Defines.h DMRSync.h DStarEcho.h YSFEcho.h DMRControl.h HomebrewDMRIPSC.h \ + Display.h TFTSerial.h NullDisplay.h + $(CC) $(CFLAGS) -c MMDVMHost.cpp + +Modem.o: Modem.cpp Modem.h Log.h SerialController.h Timer.h RingBuffer.h Utils.o DMRDefines.h DStarDefines.h YSFDefines.h Defines.h + $(CC) $(CFLAGS) -c Modem.cpp + +NullDisplay.o: NullDisplay.cpp NullDisplay.h Display.h + $(CC) $(CFLAGS) -c NullDisplay.cpp + +QR1676.o: QR1676.cpp QR1676.h Log.h + $(CC) $(CFLAGS) -c QR1676.cpp + +RS129.o: RS129.cpp RS129.h + $(CC) $(CFLAGS) -c RS129.cpp + +SerialController.o: SerialController.cpp SerialController.h Log.h + $(CC) $(CFLAGS) -c SerialController.cpp + +SHA256.o: SHA256.cpp SHA256.h + $(CC) $(CFLAGS) -c SHA256.cpp + +ShortLC.o: ShortLC.cpp ShortLC.h Utils.h Hamming.h + $(CC) $(CFLAGS) -c ShortLC.cpp + +SlotType.o: SlotType.cpp SlotType.h Golay2087.h + $(CC) $(CFLAGS) -c SlotType.cpp + +StopWatch.o: StopWatch.cpp StopWatch.h + $(CC) $(CFLAGS) -c StopWatch.cpp + +TFTSerial.o: TFTSerial.cpp TFTSerial.h Display.h SerialController.h Log.h + $(CC) $(CFLAGS) -c TFTSerial.cpp + +Timer.o: Timer.cpp Timer.h + $(CC) $(CFLAGS) -c Timer.cpp + +UDPSocket.o: UDPSocket.cpp UDPSocket.h Log.h + $(CC) $(CFLAGS) -c UDPSocket.cpp + +Utils.o: Utils.cpp Utils.h Log.h + $(CC) $(CFLAGS) -c Utils.cpp + +YSFEcho.o: YSFEcho.cpp YSFEcho.h YSFDefines.h RingBuffer.h Timer.h + $(CC) $(CFLAGS) -c YSFEcho.cpp + +clean: + $(RM) MMDVMHost *.o *.bak *~ diff --git a/Modem.cpp b/Modem.cpp new file mode 100644 index 0000000..a09cc1e --- /dev/null +++ b/Modem.cpp @@ -0,0 +1,884 @@ +/* + * Copyright (C) 2011-2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "DStarDefines.h" +#include "DMRDefines.h" +#include "YSFDefines.h" +#include "Defines.h" +#include "Modem.h" +#include "Utils.h" +#include "Log.h" + +#include +#include + +#if defined(_WIN32) || defined(_WIN64) +#include +typedef unsigned int uint32_t; +#else +#include +#include +#endif + +const unsigned char MMDVM_FRAME_START = 0xE0U; + +const unsigned char MMDVM_GET_VERSION = 0x00U; +const unsigned char MMDVM_GET_STATUS = 0x01U; +const unsigned char MMDVM_SET_CONFIG = 0x02U; +const unsigned char MMDVM_SET_MODE = 0x03U; + +const unsigned char MMDVM_DSTAR_HEADER = 0x10U; +const unsigned char MMDVM_DSTAR_DATA = 0x11U; +const unsigned char MMDVM_DSTAR_LOST = 0x12U; +const unsigned char MMDVM_DSTAR_EOT = 0x13U; + +const unsigned char MMDVM_DMR_DATA1 = 0x18U; +const unsigned char MMDVM_DMR_LOST1 = 0x19U; +const unsigned char MMDVM_DMR_DATA2 = 0x1AU; +const unsigned char MMDVM_DMR_LOST2 = 0x1BU; +const unsigned char MMDVM_DMR_SHORTLC = 0x1CU; +const unsigned char MMDVM_DMR_START = 0x1DU; + +const unsigned char MMDVM_YSF_DATA = 0x20U; +const unsigned char MMDVM_YSF_LOST = 0x21U; + +const unsigned char MMDVM_ACK = 0x70U; +const unsigned char MMDVM_NAK = 0x7FU; + +const unsigned char MMDVM_DUMP = 0xF0U; +const unsigned char MMDVM_DEBUG1 = 0xF1U; +const unsigned char MMDVM_DEBUG2 = 0xF2U; +const unsigned char MMDVM_DEBUG3 = 0xF3U; +const unsigned char MMDVM_DEBUG4 = 0xF4U; +const unsigned char MMDVM_DEBUG5 = 0xF5U; +const unsigned char MMDVM_SAMPLES = 0xF8U; + +const unsigned int MAX_RESPONSES = 30U; + +const unsigned int BUFFER_LENGTH = 500U; + + +CModem::CModem(const std::string& port, bool rxInvert, bool txInvert, bool pttInvert, unsigned int txDelay, unsigned int rxLevel, unsigned int txLevel, bool debug) : +m_port(port), +m_colorCode(0U), +m_rxInvert(rxInvert), +m_txInvert(txInvert), +m_pttInvert(pttInvert), +m_txDelay(txDelay), +m_rxLevel(rxLevel), +m_txLevel(txLevel), +m_debug(debug), +m_dstarEnabled(false), +m_dmrEnabled(false), +m_ysfEnabled(false), +m_serial(port, SERIAL_115200, true), +m_buffer(NULL), +m_rxDStarData(1000U), +m_txDStarData(1000U), +m_rxDMRData1(1000U), +m_rxDMRData2(1000U), +m_txDMRData1(1000U), +m_txDMRData2(1000U), +m_rxYSFData(1000U), +m_txYSFData(1000U), +m_statusTimer(1000U, 0U, 100U), +m_dstarSpace(0U), +m_dmrSpace1(0U), +m_dmrSpace2(0U), +m_ysfSpace(0U), +m_tx(false) +{ + assert(!port.empty()); + + m_buffer = new unsigned char[BUFFER_LENGTH]; +} + +CModem::~CModem() +{ + delete[] m_buffer; +} + +void CModem::setModeParams(bool dstarEnabled, bool dmrEnabled, bool ysfEnabled) +{ + m_dstarEnabled = dstarEnabled; + m_dmrEnabled = dmrEnabled; + m_ysfEnabled = ysfEnabled; +} + +void CModem::setDMRParams(unsigned int colorCode) +{ + assert(colorCode < 16U); + + m_colorCode = colorCode; +} + +bool CModem::open() +{ + ::LogMessage("Opening the MMDVM"); + + bool ret = m_serial.open(); + if (!ret) + return false; + + ret = readVersion(); + if (!ret) { + m_serial.close(); + return false; + } + + ret = setConfig(); + if (!ret) { + m_serial.close(); + return false; + } + + m_statusTimer.start(); + + return true; +} + +void CModem::clock(unsigned int ms) +{ + // Poll the modem status every 100ms + m_statusTimer.clock(ms); + if (m_statusTimer.hasExpired()) { + readStatus(); + m_statusTimer.start(); + } + + unsigned int length; + RESP_TYPE_MMDVM type = getResponse(m_buffer, length); + + if (type == RTM_TIMEOUT) { + // Nothing to do + } else if (type == RTM_ERROR) { + LogError("Error when reading from the MMDVM"); + } else { + // type == RTM_OK + switch (m_buffer[2U]) { + case MMDVM_DSTAR_HEADER: { + if (m_debug) + CUtils::dump(1U, "RX D-Star Header", m_buffer, length); + + unsigned char data = length - 2U; + m_rxDStarData.addData(&data, 1U); + + data = TAG_HEADER; + m_rxDStarData.addData(&data, 1U); + + m_rxDStarData.addData(m_buffer + 3U, length - 3U); + } + break; + + case MMDVM_DSTAR_DATA: { + if (m_debug) + CUtils::dump(1U, "RX D-Star Data", m_buffer, length); + + unsigned char data = length - 2U; + m_rxDStarData.addData(&data, 1U); + + data = TAG_DATA; + m_rxDStarData.addData(&data, 1U); + + m_rxDStarData.addData(m_buffer + 3U, length - 3U); + } + break; + + case MMDVM_DSTAR_LOST: { + if (m_debug) + CUtils::dump(1U, "RX D-Star Lost", m_buffer, length); + + unsigned char data = 1U; + m_rxDStarData.addData(&data, 1U); + + data = TAG_LOST; + m_rxDStarData.addData(&data, 1U); + } + break; + + case MMDVM_DSTAR_EOT: { + if (m_debug) + CUtils::dump(1U, "RX D-Star EOT", m_buffer, length); + + unsigned char data = 1U; + m_rxDStarData.addData(&data, 1U); + + data = TAG_EOT; + m_rxDStarData.addData(&data, 1U); + } + break; + + case MMDVM_DMR_DATA1: { + if (m_debug) + CUtils::dump(1U, "RX DMR Data 1", m_buffer, length); + + unsigned char data = length - 2U; + m_rxDMRData1.addData(&data, 1U); + + if (m_buffer[3U] == (DMR_SYNC_DATA | DT_TERMINATOR_WITH_LC)) + data = TAG_EOT; + else + data = TAG_DATA; + m_rxDMRData1.addData(&data, 1U); + + m_rxDMRData1.addData(m_buffer + 3U, length - 3U); + } + break; + + case MMDVM_DMR_DATA2: { + if (m_debug) + CUtils::dump(1U, "RX DMR Data 2", m_buffer, length); + + unsigned char data = length - 2U; + m_rxDMRData2.addData(&data, 1U); + + if (m_buffer[3U] == (DMR_SYNC_DATA | DT_TERMINATOR_WITH_LC)) + data = TAG_EOT; + else + data = TAG_DATA; + m_rxDMRData2.addData(&data, 1U); + + m_rxDMRData2.addData(m_buffer + 3U, length - 3U); + } + break; + + case MMDVM_DMR_LOST1: { + if (m_debug) + CUtils::dump(1U, "RX DMR Lost 1", m_buffer, length); + + unsigned char data = 1U; + m_rxDMRData1.addData(&data, 1U); + + data = TAG_LOST; + m_rxDMRData1.addData(&data, 1U); + } + break; + + case MMDVM_DMR_LOST2: { + if (m_debug) + CUtils::dump(1U, "RX DMR Lost 2", m_buffer, length); + + unsigned char data = 1U; + m_rxDMRData2.addData(&data, 1U); + + data = TAG_LOST; + m_rxDMRData2.addData(&data, 1U); + } + break; + + case MMDVM_YSF_DATA: { + if (m_debug) + CUtils::dump(1U, "RX YSF Data", m_buffer, length); + + unsigned char data = length - 2U; + m_rxYSFData.addData(&data, 1U); + + if ((m_buffer[3U] & (YSF_CKSUM_OK | YSF_FI_MASK)) == (YSF_CKSUM_OK | YSF_DT_TERMINATOR_CHANNEL)) + data = TAG_EOT; + else + data = TAG_DATA; + m_rxYSFData.addData(&data, 1U); + + m_rxYSFData.addData(m_buffer + 3U, length - 3U); + } + break; + + case MMDVM_YSF_LOST: { + if (m_debug) + CUtils::dump(1U, "RX YSF Lost", m_buffer, length); + + unsigned char data = 1U; + m_rxYSFData.addData(&data, 1U); + + data = TAG_LOST; + m_rxYSFData.addData(&data, 1U); + } + break; + + case MMDVM_GET_STATUS: { + // if (m_debug) + // CUtils::dump(1U, "GET_STATUS", m_buffer, length); + + m_tx = (m_buffer[5U] & 0x01U) == 0x01U; + + bool adcOverflow = (m_buffer[5U] & 0x02U) == 0x02U; + if (adcOverflow) + LogWarning("MMDVM ADC levels have overflowed"); + + m_dstarSpace = m_buffer[6U]; + m_dmrSpace1 = m_buffer[7U]; + m_dmrSpace2 = m_buffer[8U]; + m_ysfSpace = m_buffer[9U]; + // LogMessage("tx=%d, space=%u,%u,%u,%u", int(m_tx), m_dstarSpace, m_dmrSpace1, m_dmrSpace2, m_ysfSpace); + } + break; + + // These should not be received, but don't complain if we do + case MMDVM_GET_VERSION: + case MMDVM_ACK: + break; + + case MMDVM_NAK: + LogWarning("Received a NAK from the MMDVM, command = 0x%02X, reason = %u", m_buffer[3U], m_buffer[4U]); + break; + + case MMDVM_DEBUG1: + case MMDVM_DEBUG2: + case MMDVM_DEBUG3: + case MMDVM_DEBUG4: + case MMDVM_DEBUG5: + printDebug(); + break; + + case MMDVM_SAMPLES: + // printSamples(); + break; + + default: + LogMessage("Unknown message, type: %02X", m_buffer[2U]); + CUtils::dump("Buffer dump", m_buffer, length); + break; + } + } + + if (m_dstarSpace > 1U && !m_txDStarData.isEmpty()) { + unsigned char len = 0U; + m_txDStarData.getData(&len, 1U); + m_txDStarData.getData(m_buffer, len); + + if (m_debug) { + if (len > (DSTAR_FRAME_LENGTH_BYTES + 3U)) + CUtils::dump(1U, "TX D-Star Header", m_buffer, len); + else if (len == (DSTAR_FRAME_LENGTH_BYTES + 3U)) + CUtils::dump(1U, "TX D-Star Data", m_buffer, len); + else + CUtils::dump(1U, "TX D-Star EOT", m_buffer, len); + } + + int ret = m_serial.write(m_buffer, len); + if (ret != int(len)) + LogWarning("Error when writing D-Star data to the MMDVM"); + + // Headers take four slots in the queues in the modem + if (len > (DSTAR_FRAME_LENGTH_BYTES + 3U)) + m_dstarSpace -= 4U; + else + m_dstarSpace -= 1U; + } + + if (m_dmrSpace1 > 1U && !m_txDMRData1.isEmpty()) { + unsigned char len = 0U; + m_txDMRData1.getData(&len, 1U); + m_txDMRData1.getData(m_buffer, len); + + if (m_debug) + CUtils::dump(1U, "TX DMR Data 1", m_buffer, len); + + int ret = m_serial.write(m_buffer, len); + if (ret != int(len)) + LogWarning("Error when writing DMR data to the MMDVM"); + + m_dmrSpace1--; + } + + if (m_dmrSpace2 > 1U && !m_txDMRData2.isEmpty()) { + unsigned char len = 0U; + m_txDMRData2.getData(&len, 1U); + m_txDMRData2.getData(m_buffer, len); + + if (m_debug) + CUtils::dump(1U, "TX DMR Data 2", m_buffer, len); + + int ret = m_serial.write(m_buffer, len); + if (ret != int(len)) + LogWarning("Error when writing DMR data to the MMDVM"); + + m_dmrSpace2--; + } + + if (m_ysfSpace > 1U && !m_txYSFData.isEmpty()) { + unsigned char len = 0U; + m_txYSFData.getData(&len, 1U); + m_txYSFData.getData(m_buffer, len); + + if (m_debug) + CUtils::dump(1U, "TX YSF Data", m_buffer, len); + + int ret = m_serial.write(m_buffer, len); + if (ret != int(len)) + LogWarning("Error when writing YSF data to the MMDVM"); + + m_ysfSpace--; + } +} + +void CModem::close() +{ + ::LogMessage("Closing the MMDVM"); + + delete[] m_buffer; + + m_serial.close(); +} + +unsigned int CModem::readDStarData(unsigned char* data) +{ + assert(data != NULL); + + if (m_rxDStarData.isEmpty()) + return 0U; + + unsigned char len = 0U; + m_rxDStarData.getData(&len, 1U); + m_rxDStarData.getData(data, len); + + return len; +} + +unsigned int CModem::readDMRData1(unsigned char* data) +{ + assert(data != NULL); + + if (m_rxDMRData1.isEmpty()) + return 0U; + + unsigned char len = 0U; + m_rxDMRData1.getData(&len, 1U); + m_rxDMRData1.getData(data, len); + + return len; +} + +unsigned int CModem::readDMRData2(unsigned char* data) +{ + assert(data != NULL); + + if (m_rxDMRData2.isEmpty()) + return 0U; + + unsigned char len = 0U; + m_rxDMRData2.getData(&len, 1U); + m_rxDMRData2.getData(data, len); + + return len; +} + +unsigned int CModem::readYSFData(unsigned char* data) +{ + assert(data != NULL); + + if (m_rxYSFData.isEmpty()) + return 0U; + + unsigned char len = 0U; + m_rxYSFData.getData(&len, 1U); + m_rxYSFData.getData(data, len); + + return len; +} + +bool CModem::hasDStarSpace() const +{ + unsigned int space = m_txDStarData.freeSpace() / (DSTAR_FRAME_LENGTH_BYTES + 4U); + + return space > 1U; +} + +bool CModem::writeDStarData(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + unsigned char buffer[50U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = length + 2U; + + switch (data[0U]) { + case TAG_HEADER: buffer[2U] = MMDVM_DSTAR_HEADER; break; + case TAG_DATA: buffer[2U] = MMDVM_DSTAR_DATA; break; + case TAG_EOT: buffer[2U] = MMDVM_DSTAR_EOT; break; + default: return false; + } + + ::memcpy(buffer + 3U, data + 1U, length - 1U); + + unsigned char len = length + 2U; + m_txDStarData.addData(&len, 1U); + m_txDStarData.addData(buffer, len); + + return true; +} + +bool CModem::hasDMRSpace1() const +{ + unsigned int space = m_txDMRData1.freeSpace() / (DMR_FRAME_LENGTH_BYTES + 4U); + + return space > 1U; +} + +bool CModem::hasDMRSpace2() const +{ + unsigned int space = m_txDMRData2.freeSpace() / (DMR_FRAME_LENGTH_BYTES + 4U); + + return space > 1U; +} + +bool CModem::writeDMRData1(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + if (data[0U] != TAG_DATA && data[0U] != TAG_EOT) + return false; + + unsigned char buffer[40U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = length + 2U; + buffer[2U] = MMDVM_DMR_DATA1; + + ::memcpy(buffer + 3U, data + 1U, length - 1U); + + unsigned char len = length + 2U; + m_txDMRData1.addData(&len, 1U); + m_txDMRData1.addData(buffer, len); + + return true; +} + +bool CModem::writeDMRData2(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + if (data[0U] != TAG_DATA && data[0U] != TAG_EOT) + return false; + + unsigned char buffer[40U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = length + 2U; + buffer[2U] = MMDVM_DMR_DATA2; + + ::memcpy(buffer + 3U, data + 1U, length - 1U); + + unsigned char len = length + 2U; + m_txDMRData2.addData(&len, 1U); + m_txDMRData2.addData(buffer, len); + + return true; +} + +bool CModem::hasYSFSpace() const +{ + unsigned int space = m_txYSFData.freeSpace() / (YSF_FRAME_LENGTH_BYTES + 4U); + + return space > 1U; +} + +bool CModem::writeYSFData(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + if (data[0U] != TAG_DATA && data[0U] != TAG_EOT) + return false; + + unsigned char buffer[130U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = length + 2U; + buffer[2U] = MMDVM_YSF_DATA; + + ::memcpy(buffer + 3U, data + 1U, length - 1U); + + unsigned char len = length + 2U; + m_txYSFData.addData(&len, 1U); + m_txYSFData.addData(buffer, len); + + return true; +} + +bool CModem::readVersion() +{ +#if defined(_WIN32) || defined(_WIN64) + ::Sleep(2000UL); // 2s +#else + ::sleep(2); // 2s +#endif + + for (unsigned int i = 0U; i < 6U; i++) { + unsigned char buffer[3U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = 3U; + buffer[2U] = MMDVM_GET_VERSION; + + // CUtils::dump("Written", buffer, 3U); + + int ret = m_serial.write(buffer, 3U); + if (ret != 3) + return false; + + for (unsigned int count = 0U; count < MAX_RESPONSES; count++) { +#if defined(_WIN32) || defined(_WIN64) + ::Sleep(10UL); +#else + ::usleep(10000UL); +#endif + unsigned int length; + RESP_TYPE_MMDVM resp = getResponse(m_buffer, length); + if (resp == RTM_OK && m_buffer[2U] == MMDVM_GET_VERSION) { + LogInfo("MMDVM protocol version: %u, description: %.*s", m_buffer[3U], length - 4U, m_buffer + 4U); + return true; + } + } + +#if defined(_WIN32) || defined(_WIN64) + ::Sleep(1000UL); // 1s +#else + ::sleep(1UL); // 1s +#endif + } + + LogError("Unable to read the firmware version after six attempts"); + + return false; +} + +bool CModem::readStatus() +{ + unsigned char buffer[3U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = 3U; + buffer[2U] = MMDVM_GET_STATUS; + + return m_serial.write(buffer, 3U) == 3; +} + +bool CModem::setConfig() +{ + unsigned char buffer[10U]; + + buffer[0U] = MMDVM_FRAME_START; + + buffer[1U] = 10U; + + buffer[2U] = MMDVM_SET_CONFIG; + + buffer[3U] = 0x00U; + if (m_rxInvert) + buffer[3U] |= 0x01U; + if (m_txInvert) + buffer[3U] |= 0x02U; + if (m_pttInvert) + buffer[3U] |= 0x04U; + + buffer[4U] = 0x00U; + if (m_dstarEnabled) + buffer[4U] |= 0x01U; + if (m_dmrEnabled) + buffer[4U] |= 0x02U; + if (m_ysfEnabled) + buffer[4U] |= 0x04U; + + buffer[5U] = m_txDelay / 10U; // In 10ms units + + buffer[6U] = MODE_IDLE; + + buffer[7U] = (m_rxLevel * 255U) / 100U; + buffer[8U] = (m_txLevel * 255U) / 100U; + + buffer[9U] = m_colorCode; + + // CUtils::dump("Written", buffer, 10U); + + int ret = m_serial.write(buffer, 10U); + if (ret != 10) + return false; + + unsigned int count = 0U; + unsigned int length; + RESP_TYPE_MMDVM resp; + do { +#if defined(_WIN32) || defined(_WIN64) + ::Sleep(10UL); +#else + ::usleep(10000UL); +#endif + resp = getResponse(m_buffer, length); + + if (resp == RTM_OK && m_buffer[2U] != MMDVM_ACK && m_buffer[2U] != MMDVM_NAK) { + count++; + if (count >= MAX_RESPONSES) { + LogError("The MMDVM is not responding to the SET_CONFIG command"); + return false; + } + } + } while (resp == RTM_OK && m_buffer[2U] != MMDVM_ACK && m_buffer[2U] != MMDVM_NAK); + + // CUtils::dump("Response", m_buffer, length); + + if (resp == RTM_OK && m_buffer[2U] == MMDVM_NAK) { + LogError("Received a NAK to the SET_CONFIG command from the modem"); + return false; + } + + return true; +} + +RESP_TYPE_MMDVM CModem::getResponse(unsigned char *buffer, unsigned int& length) +{ + // Get the start of the frame or nothing at all + int ret = m_serial.read(buffer + 0U, 1U); + if (ret < 0) { + LogError("Error when reading from the modem"); + return RTM_ERROR; + } + + if (ret == 0) + return RTM_TIMEOUT; + + if (buffer[0U] != MMDVM_FRAME_START) + return RTM_TIMEOUT; + + ret = m_serial.read(buffer + 1U, 1U); + if (ret < 0) { + LogError("Error when reading from the modem"); + return RTM_ERROR; + } + + if (ret == 0) + return RTM_TIMEOUT; + + length = buffer[1U]; + + if (length >= 200U) { + LogError("Invalid data received from the modem"); + return RTM_ERROR; + } + + unsigned int offset = 2U; + + while (offset < length) { + int ret = m_serial.read(buffer + offset, length - offset); + if (ret < 0) { + LogError("Error when reading from the modem"); + return RTM_ERROR; + } + + if (ret > 0) + offset += ret; + + if (ret == 0) +#if defined(_WIN32) || defined(_WIN64) + ::Sleep(5UL); // 5ms +#else + ::usleep(5000); // 5ms +#endif + } + + // CUtils::dump("Received", buffer, length); + + return RTM_OK; +} + +bool CModem::setMode(unsigned char mode) +{ + unsigned char buffer[4U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = 4U; + buffer[2U] = MMDVM_SET_MODE; + buffer[3U] = mode; + + // CUtils::dump("Written", buffer, 4U); + + return m_serial.write(buffer, 4U) == 4; +} + +bool CModem::writeDMRStart(bool tx) +{ + if (tx && m_tx) + return true; + if (!tx && !m_tx) + return true; + + unsigned char buffer[4U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = 4U; + buffer[2U] = MMDVM_DMR_START; + buffer[3U] = tx ? 0x01U : 0x00U; + + // CUtils::dump("Written", buffer, 4U); + + return m_serial.write(buffer, 4U) == 4; +} + +bool CModem::writeDMRShortLC(const unsigned char* lc) +{ + assert(lc != NULL); + + unsigned char buffer[12U]; + + buffer[0U] = MMDVM_FRAME_START; + buffer[1U] = 12U; + buffer[2U] = MMDVM_DMR_SHORTLC; + buffer[3U] = lc[0U]; + buffer[4U] = lc[1U]; + buffer[5U] = lc[2U]; + buffer[6U] = lc[3U]; + buffer[7U] = lc[4U]; + buffer[8U] = lc[5U]; + buffer[9U] = lc[6U]; + buffer[10U] = lc[7U]; + buffer[11U] = lc[8U]; + + // CUtils::dump("Written", buffer, 12U); + + return m_serial.write(buffer, 12U) == 12; +} + +void CModem::printDebug() +{ + unsigned int length = m_buffer[1U]; + if (m_buffer[2U] == 0xF1U) { + LogMessage("Debug: %.*s", length - 3U, m_buffer + 3U); + } else if (m_buffer[2U] == 0xF2U) { + short val1 = (m_buffer[length - 2U] << 8) | m_buffer[length - 1U]; + LogMessage("Debug: %.*s %d", length - 5U, m_buffer + 3U, val1); + } else if (m_buffer[2U] == 0xF3U) { + short val1 = (m_buffer[length - 4U] << 8) | m_buffer[length - 3U]; + short val2 = (m_buffer[length - 2U] << 8) | m_buffer[length - 1U]; + LogMessage("Debug: %.*s %d %d", length - 7U, m_buffer + 3U, val1, val2); + } else if (m_buffer[2U] == 0xF4U) { + short val1 = (m_buffer[length - 6U] << 8) | m_buffer[length - 5U]; + short val2 = (m_buffer[length - 4U] << 8) | m_buffer[length - 3U]; + short val3 = (m_buffer[length - 2U] << 8) | m_buffer[length - 1U]; + LogMessage("Debug: %.*s %d %d %d", length - 9U, m_buffer + 3U, val1, val2, val3); + } else if (m_buffer[2U] == 0xF5U) { + short val1 = (m_buffer[length - 8U] << 8) | m_buffer[length - 7U]; + short val2 = (m_buffer[length - 6U] << 8) | m_buffer[length - 5U]; + short val3 = (m_buffer[length - 4U] << 8) | m_buffer[length - 3U]; + short val4 = (m_buffer[length - 2U] << 8) | m_buffer[length - 1U]; + LogMessage("Debug: %.*s %d %d %d %d", length - 11U, m_buffer + 3U, val1, val2, val3, val4); + } +} diff --git a/Modem.h b/Modem.h new file mode 100644 index 0000000..ed0e3db --- /dev/null +++ b/Modem.h @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2011-2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef MODEM_H +#define MODEM_H + +#include "SerialController.h" +#include "RingBuffer.h" +#include "Timer.h" + +#include + +enum RESP_TYPE_MMDVM { + RTM_OK, + RTM_TIMEOUT, + RTM_ERROR +}; + +class CModem { +public: + CModem(const std::string& port, bool rxInvert, bool txInvert, bool pttInvert, unsigned int txDelay, unsigned int rxLevel, unsigned int txLevel, bool debug = false); + virtual ~CModem(); + + virtual void setModeParams(bool dstarEnabled, bool dmrEnabled, bool ysfEnabled); + virtual void setDMRParams(unsigned int colorCode); + + virtual bool open(); + + virtual unsigned int readDStarData(unsigned char* data); + virtual unsigned int readDMRData1(unsigned char* data); + virtual unsigned int readDMRData2(unsigned char* data); + virtual unsigned int readYSFData(unsigned char* data); + + virtual bool hasDStarSpace() const; + virtual bool hasDMRSpace1() const; + virtual bool hasDMRSpace2() const; + virtual bool hasYSFSpace() const; + + virtual bool writeDStarData(const unsigned char* data, unsigned int length); + virtual bool writeDMRData1(const unsigned char* data, unsigned int length); + virtual bool writeDMRData2(const unsigned char* data, unsigned int length); + virtual bool writeYSFData(const unsigned char* data, unsigned int length); + + virtual bool writeDMRStart(bool tx); + virtual bool writeDMRShortLC(const unsigned char* lc); + + virtual bool setMode(unsigned char mode); + + virtual void clock(unsigned int ms); + + virtual void close(); + +private: + std::string m_port; + unsigned int m_colorCode; + bool m_rxInvert; + bool m_txInvert; + bool m_pttInvert; + unsigned int m_txDelay; + unsigned int m_rxLevel; + unsigned int m_txLevel; + bool m_debug; + bool m_dstarEnabled; + bool m_dmrEnabled; + bool m_ysfEnabled; + CSerialController m_serial; + unsigned char* m_buffer; + CRingBuffer m_rxDStarData; + CRingBuffer m_txDStarData; + CRingBuffer m_rxDMRData1; + CRingBuffer m_rxDMRData2; + CRingBuffer m_txDMRData1; + CRingBuffer m_txDMRData2; + CRingBuffer m_rxYSFData; + CRingBuffer m_txYSFData; + CTimer m_statusTimer; + unsigned int m_dstarSpace; + unsigned int m_dmrSpace1; + unsigned int m_dmrSpace2; + unsigned int m_ysfSpace; + bool m_tx; + + bool readVersion(); + bool readStatus(); + bool setConfig(); + + void printDebug(); + + RESP_TYPE_MMDVM getResponse(unsigned char* buffer, unsigned int& length); +}; + +#endif diff --git a/NullDisplay.cpp b/NullDisplay.cpp new file mode 100644 index 0000000..2f6c58d --- /dev/null +++ b/NullDisplay.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "NullDisplay.h" + +CNullDisplay::CNullDisplay() +{ +} + +CNullDisplay::~CNullDisplay() +{ +} + +bool CNullDisplay::open() +{ + return true; +} + +void CNullDisplay::setIdle() +{ +} + +void CNullDisplay::setDStar() +{ +} + +void CNullDisplay::writeDStar(const std::string& call1, const std::string& call2) +{ +} + +void CNullDisplay::clearDStar() +{ +} + +void CNullDisplay::setDMR() +{ +} + +void CNullDisplay::writeDMR(unsigned int slotNo, unsigned int srcId, bool group, unsigned int dstId) +{ +} + +void CNullDisplay::clearDMR(unsigned int slotNo) +{ +} + +void CNullDisplay::setFusion() +{ +} + +void CNullDisplay::writeFusion(const std::string& callsign) +{ +} + +void CNullDisplay::clearFusion() +{ +} + +void CNullDisplay::close() +{ +} diff --git a/NullDisplay.h b/NullDisplay.h new file mode 100644 index 0000000..715f24c --- /dev/null +++ b/NullDisplay.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(NULLDISPLAY_H) +#define NULLDISPLAY_H + +#include "Display.h" + +#include + +class CNullDisplay : public IDisplay +{ +public: + CNullDisplay(); + virtual ~CNullDisplay(); + + virtual bool open(); + + virtual void setIdle(); + + virtual void setDStar(); + virtual void writeDStar(const std::string& call1, const std::string& call2); + virtual void clearDStar(); + + virtual void setDMR(); + virtual void writeDMR(unsigned int slotNo, unsigned int srdId, bool group, unsigned int dstId); + virtual void clearDMR(unsigned int slotNo); + + virtual void setFusion(); + virtual void writeFusion(const std::string& callsign); + virtual void clearFusion(); + + virtual void close(); + +private: +}; + +#endif diff --git a/QR1676.cpp b/QR1676.cpp new file mode 100644 index 0000000..1548fc5 --- /dev/null +++ b/QR1676.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "QR1676.h" +#include "Log.h" + +#include +#include + +const unsigned int ENCODING_TABLE_1676[] = + {0x0000U, 0x0273U, 0x04E5U, 0x0696U, 0x09C9U, 0x0BBAU, 0x0D2CU, 0x0F5FU, 0x11E2U, 0x1391U, 0x1507U, 0x1774U, + 0x182BU, 0x1A58U, 0x1CCEU, 0x1EBDU, 0x21B7U, 0x23C4U, 0x2552U, 0x2721U, 0x287EU, 0x2A0DU, 0x2C9BU, 0x2EE8U, + 0x3055U, 0x3226U, 0x34B0U, 0x36C3U, 0x399CU, 0x3BEFU, 0x3D79U, 0x3F0AU, 0x411EU, 0x436DU, 0x45FBU, 0x4788U, + 0x48D7U, 0x4AA4U, 0x4C32U, 0x4E41U, 0x50FCU, 0x528FU, 0x5419U, 0x566AU, 0x5935U, 0x5B46U, 0x5DD0U, 0x5FA3U, + 0x60A9U, 0x62DAU, 0x644CU, 0x663FU, 0x6960U, 0x6B13U, 0x6D85U, 0x6FF6U, 0x714BU, 0x7338U, 0x75AEU, 0x77DDU, + 0x7882U, 0x7AF1U, 0x7C67U, 0x7E14U, 0x804FU, 0x823CU, 0x84AAU, 0x86D9U, 0x8986U, 0x8BF5U, 0x8D63U, 0x8F10U, + 0x91ADU, 0x93DEU, 0x9548U, 0x973BU, 0x9864U, 0x9A17U, 0x9C81U, 0x9EF2U, 0xA1F8U, 0xA38BU, 0xA51DU, 0xA76EU, + 0xA831U, 0xAA42U, 0xACD4U, 0xAEA7U, 0xB01AU, 0xB269U, 0xB4FFU, 0xB68CU, 0xB9D3U, 0xBBA0U, 0xBD36U, 0xBF45U, + 0xC151U, 0xC322U, 0xC5B4U, 0xC7C7U, 0xC898U, 0xCAEBU, 0xCC7DU, 0xCE0EU, 0xD0B3U, 0xD2C0U, 0xD456U, 0xD625U, + 0xD97AU, 0xDB09U, 0xDD9FU, 0xDFECU, 0xE0E6U, 0xE295U, 0xE403U, 0xE670U, 0xE92FU, 0xEB5CU, 0xEDCAU, 0xEFB9U, + 0xF104U, 0xF377U, 0xF5E1U, 0xF792U, 0xF8CDU, 0xFABEU, 0xFC28U, 0xFE5BU}; + +const unsigned int DECODING_TABLE_1576[] = + {0x0000U, 0x0001U, 0x0002U, 0x0003U, 0x0004U, 0x0005U, 0x0006U, 0x4020U, 0x0008U, 0x0009U, 0x000AU, 0x000BU, + 0x000CU, 0x000DU, 0x2081U, 0x2080U, 0x0010U, 0x0011U, 0x0012U, 0x0013U, 0x0014U, 0x0C00U, 0x0016U, 0x0C02U, + 0x0018U, 0x0120U, 0x001AU, 0x0122U, 0x4102U, 0x0124U, 0x4100U, 0x4101U, 0x0020U, 0x0021U, 0x0022U, 0x4004U, + 0x0024U, 0x4002U, 0x4001U, 0x4000U, 0x0028U, 0x0110U, 0x1800U, 0x1801U, 0x002CU, 0x400AU, 0x4009U, 0x4008U, + 0x0030U, 0x0108U, 0x0240U, 0x0241U, 0x0034U, 0x4012U, 0x4011U, 0x4010U, 0x0101U, 0x0100U, 0x0103U, 0x0102U, + 0x0105U, 0x0104U, 0x1401U, 0x1400U, 0x0040U, 0x0041U, 0x0042U, 0x0043U, 0x0044U, 0x0045U, 0x0046U, 0x4060U, + 0x0048U, 0x0049U, 0x0301U, 0x0300U, 0x004CU, 0x1600U, 0x0305U, 0x0304U, 0x0050U, 0x0051U, 0x0220U, 0x0221U, + 0x3000U, 0x4200U, 0x3002U, 0x4202U, 0x0058U, 0x1082U, 0x1081U, 0x1080U, 0x3008U, 0x4208U, 0x2820U, 0x1084U, + 0x0060U, 0x0061U, 0x0210U, 0x0211U, 0x0480U, 0x0481U, 0x4041U, 0x4040U, 0x0068U, 0x2402U, 0x2401U, 0x2400U, + 0x0488U, 0x3100U, 0x2810U, 0x2404U, 0x0202U, 0x0880U, 0x0200U, 0x0201U, 0x0206U, 0x0884U, 0x0204U, 0x0205U, + 0x0141U, 0x0140U, 0x0208U, 0x0209U, 0x2802U, 0x0144U, 0x2800U, 0x2801U, 0x0080U, 0x0081U, 0x0082U, 0x0A00U, + 0x0084U, 0x0085U, 0x2009U, 0x2008U, 0x0088U, 0x0089U, 0x2005U, 0x2004U, 0x2003U, 0x2002U, 0x2001U, 0x2000U, + 0x0090U, 0x0091U, 0x0092U, 0x1048U, 0x0602U, 0x0C80U, 0x0600U, 0x0601U, 0x0098U, 0x1042U, 0x1041U, 0x1040U, + 0x2013U, 0x2012U, 0x2011U, 0x2010U, 0x00A0U, 0x00A1U, 0x00A2U, 0x4084U, 0x0440U, 0x0441U, 0x4081U, 0x4080U, + 0x6000U, 0x1200U, 0x6002U, 0x1202U, 0x6004U, 0x2022U, 0x2021U, 0x2020U, 0x0841U, 0x0840U, 0x2104U, 0x0842U, + 0x2102U, 0x0844U, 0x2100U, 0x2101U, 0x0181U, 0x0180U, 0x0B00U, 0x0182U, 0x5040U, 0x0184U, 0x2108U, 0x2030U, + 0x00C0U, 0x00C1U, 0x4401U, 0x4400U, 0x0420U, 0x0421U, 0x0422U, 0x4404U, 0x0900U, 0x0901U, 0x1011U, 0x1010U, + 0x0904U, 0x2042U, 0x2041U, 0x2040U, 0x0821U, 0x0820U, 0x1009U, 0x1008U, 0x4802U, 0x0824U, 0x4800U, 0x4801U, + 0x1003U, 0x1002U, 0x1001U, 0x1000U, 0x0501U, 0x0500U, 0x1005U, 0x1004U, 0x0404U, 0x0810U, 0x1100U, 0x1101U, + 0x0400U, 0x0401U, 0x0402U, 0x0403U, 0x040CU, 0x0818U, 0x1108U, 0x1030U, 0x0408U, 0x0409U, 0x040AU, 0x2060U, + 0x0801U, 0x0800U, 0x0280U, 0x0802U, 0x0410U, 0x0804U, 0x0412U, 0x0806U, 0x0809U, 0x0808U, 0x1021U, 0x1020U, + 0x5000U, 0x2200U, 0x5002U, 0x2202U}; + +#define X14 0x00004000 /* vector representation of X^{14} */ +#define X8 0x00000100 /* vector representation of X^{8} */ +#define MASK7 0xffffff00 /* auxiliary vector for testing */ +#define GENPOL 0x00000139 /* generator polinomial, g(x) */ + +unsigned int CQR1676::getSyndrome1576(unsigned int pattern) +/* + * Compute the syndrome corresponding to the given pattern, i.e., the + * remainder after dividing the pattern (when considering it as the vector + * representation of a polynomial) by the generator polynomial, GENPOL. + * In the program this pattern has several meanings: (1) pattern = infomation + * bits, when constructing the encoding table; (2) pattern = error pattern, + * when constructing the decoding table; and (3) pattern = received vector, to + * obtain its syndrome in decoding. + */ +{ + unsigned int aux = X14; + + if (pattern >= X8) { + while (pattern & MASK7) { + while (!(aux & pattern)) + aux = aux >> 1; + + pattern ^= (aux / X8) * GENPOL; + } + } + + return pattern; +} + +// Compute the EMB against a precomputed list of correct words +void CQR1676::encode(unsigned char* data) +{ + assert(data != NULL); + + unsigned int value = (data[0U] >> 1) & 0x7FU; + unsigned int cksum = ENCODING_TABLE_1676[value]; + + data[0U] = cksum >> 8; + data[1U] = cksum & 0xFFU; +} + +unsigned char CQR1676::decode(const unsigned char* data) +{ + assert(data != NULL); + + unsigned int code = (data[0U] << 7) + (data[1U] >> 1); + unsigned int syndrome = getSyndrome1576(code); + unsigned int error_pattern = DECODING_TABLE_1576[syndrome]; + + code ^= error_pattern; + + return code >> 7; +} diff --git a/QR1676.h b/QR1676.h new file mode 100644 index 0000000..dac2c0f --- /dev/null +++ b/QR1676.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef QR1676_H +#define QR1676_H + +class CQR1676 { +public: + static void encode(unsigned char* data); + + static unsigned char decode(const unsigned char* data); + +private: + static unsigned int getSyndrome1576(unsigned int pattern); +}; + +#endif diff --git a/README.md b/README.md new file mode 100644 index 0000000..bd35feb --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +These are the source files for builing the MMDVMHost, the program that +interfaces to the MMDVM on one side, and a network on the other. + +It supports D-Star, DMR, and System Fusion. + +It builds on Linux as well as Windows using VS2015 on x86 and x64. diff --git a/RS129.cpp b/RS129.cpp new file mode 100644 index 0000000..8cad52c --- /dev/null +++ b/RS129.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "RS129.h" + +#include +#include +#include + +const unsigned int NPAR = 3U; + +/* Maximum degree of various polynomials. */ +const unsigned int MAXDEG = NPAR * 2U; + +/* Generator Polynomial */ +const unsigned char POLY[] = {64U, 56U, 14U, 1U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}; + +const unsigned char EXP_TABLE[] = { + 0x01U, 0x02U, 0x04U, 0x08U, 0x10U, 0x20U, 0x40U, 0x80U, 0x1DU, 0x3AU, 0x74U, 0xE8U, 0xCDU, 0x87U, 0x13U, 0x26U, + 0x4CU, 0x98U, 0x2DU, 0x5AU, 0xB4U, 0x75U, 0xEAU, 0xC9U, 0x8FU, 0x03U, 0x06U, 0x0CU, 0x18U, 0x30U, 0x60U, 0xC0U, + 0x9DU, 0x27U, 0x4EU, 0x9CU, 0x25U, 0x4AU, 0x94U, 0x35U, 0x6AU, 0xD4U, 0xB5U, 0x77U, 0xEEU, 0xC1U, 0x9FU, 0x23U, + 0x46U, 0x8CU, 0x05U, 0x0AU, 0x14U, 0x28U, 0x50U, 0xA0U, 0x5DU, 0xBAU, 0x69U, 0xD2U, 0xB9U, 0x6FU, 0xDEU, 0xA1U, + 0x5FU, 0xBEU, 0x61U, 0xC2U, 0x99U, 0x2FU, 0x5EU, 0xBCU, 0x65U, 0xCAU, 0x89U, 0x0FU, 0x1EU, 0x3CU, 0x78U, 0xF0U, + 0xFDU, 0xE7U, 0xD3U, 0xBBU, 0x6BU, 0xD6U, 0xB1U, 0x7FU, 0xFEU, 0xE1U, 0xDFU, 0xA3U, 0x5BU, 0xB6U, 0x71U, 0xE2U, + 0xD9U, 0xAFU, 0x43U, 0x86U, 0x11U, 0x22U, 0x44U, 0x88U, 0x0DU, 0x1AU, 0x34U, 0x68U, 0xD0U, 0xBDU, 0x67U, 0xCEU, + 0x81U, 0x1FU, 0x3EU, 0x7CU, 0xF8U, 0xEDU, 0xC7U, 0x93U, 0x3BU, 0x76U, 0xECU, 0xC5U, 0x97U, 0x33U, 0x66U, 0xCCU, + 0x85U, 0x17U, 0x2EU, 0x5CU, 0xB8U, 0x6DU, 0xDAU, 0xA9U, 0x4FU, 0x9EU, 0x21U, 0x42U, 0x84U, 0x15U, 0x2AU, 0x54U, + 0xA8U, 0x4DU, 0x9AU, 0x29U, 0x52U, 0xA4U, 0x55U, 0xAAU, 0x49U, 0x92U, 0x39U, 0x72U, 0xE4U, 0xD5U, 0xB7U, 0x73U, + 0xE6U, 0xD1U, 0xBFU, 0x63U, 0xC6U, 0x91U, 0x3FU, 0x7EU, 0xFCU, 0xE5U, 0xD7U, 0xB3U, 0x7BU, 0xF6U, 0xF1U, 0xFFU, + 0xE3U, 0xDBU, 0xABU, 0x4BU, 0x96U, 0x31U, 0x62U, 0xC4U, 0x95U, 0x37U, 0x6EU, 0xDCU, 0xA5U, 0x57U, 0xAEU, 0x41U, + 0x82U, 0x19U, 0x32U, 0x64U, 0xC8U, 0x8DU, 0x07U, 0x0EU, 0x1CU, 0x38U, 0x70U, 0xE0U, 0xDDU, 0xA7U, 0x53U, 0xA6U, + 0x51U, 0xA2U, 0x59U, 0xB2U, 0x79U, 0xF2U, 0xF9U, 0xEFU, 0xC3U, 0x9BU, 0x2BU, 0x56U, 0xACU, 0x45U, 0x8AU, 0x09U, + 0x12U, 0x24U, 0x48U, 0x90U, 0x3DU, 0x7AU, 0xF4U, 0xF5U, 0xF7U, 0xF3U, 0xFBU, 0xEBU, 0xCBU, 0x8BU, 0x0BU, 0x16U, + 0x2CU, 0x58U, 0xB0U, 0x7DU, 0xFAU, 0xE9U, 0xCFU, 0x83U, 0x1BU, 0x36U, 0x6CU, 0xD8U, 0xADU, 0x47U, 0x8EU, 0x01U, + 0x02U, 0x04U, 0x08U, 0x10U, 0x20U, 0x40U, 0x80U, 0x1DU, 0x3AU, 0x74U, 0xE8U, 0xCDU, 0x87U, 0x13U, 0x26U, 0x4CU, + 0x98U, 0x2DU, 0x5AU, 0xB4U, 0x75U, 0xEAU, 0xC9U, 0x8FU, 0x03U, 0x06U, 0x0CU, 0x18U, 0x30U, 0x60U, 0xC0U, 0x9DU, + 0x27U, 0x4EU, 0x9CU, 0x25U, 0x4AU, 0x94U, 0x35U, 0x6AU, 0xD4U, 0xB5U, 0x77U, 0xEEU, 0xC1U, 0x9FU, 0x23U, 0x46U, + 0x8CU, 0x05U, 0x0AU, 0x14U, 0x28U, 0x50U, 0xA0U, 0x5DU, 0xBAU, 0x69U, 0xD2U, 0xB9U, 0x6FU, 0xDEU, 0xA1U, 0x5FU, + 0xBEU, 0x61U, 0xC2U, 0x99U, 0x2FU, 0x5EU, 0xBCU, 0x65U, 0xCAU, 0x89U, 0x0FU, 0x1EU, 0x3CU, 0x78U, 0xF0U, 0xFDU, + 0xE7U, 0xD3U, 0xBBU, 0x6BU, 0xD6U, 0xB1U, 0x7FU, 0xFEU, 0xE1U, 0xDFU, 0xA3U, 0x5BU, 0xB6U, 0x71U, 0xE2U, 0xD9U, + 0xAFU, 0x43U, 0x86U, 0x11U, 0x22U, 0x44U, 0x88U, 0x0DU, 0x1AU, 0x34U, 0x68U, 0xD0U, 0xBDU, 0x67U, 0xCEU, 0x81U, + 0x1FU, 0x3EU, 0x7CU, 0xF8U, 0xEDU, 0xC7U, 0x93U, 0x3BU, 0x76U, 0xECU, 0xC5U, 0x97U, 0x33U, 0x66U, 0xCCU, 0x85U, + 0x17U, 0x2EU, 0x5CU, 0xB8U, 0x6DU, 0xDAU, 0xA9U, 0x4FU, 0x9EU, 0x21U, 0x42U, 0x84U, 0x15U, 0x2AU, 0x54U, 0xA8U, + 0x4DU, 0x9AU, 0x29U, 0x52U, 0xA4U, 0x55U, 0xAAU, 0x49U, 0x92U, 0x39U, 0x72U, 0xE4U, 0xD5U, 0xB7U, 0x73U, 0xE6U, + 0xD1U, 0xBFU, 0x63U, 0xC6U, 0x91U, 0x3FU, 0x7EU, 0xFCU, 0xE5U, 0xD7U, 0xB3U, 0x7BU, 0xF6U, 0xF1U, 0xFFU, 0xE3U, + 0xDBU, 0xABU, 0x4BU, 0x96U, 0x31U, 0x62U, 0xC4U, 0x95U, 0x37U, 0x6EU, 0xDCU, 0xA5U, 0x57U, 0xAEU, 0x41U, 0x82U, + 0x19U, 0x32U, 0x64U, 0xC8U, 0x8DU, 0x07U, 0x0EU, 0x1CU, 0x38U, 0x70U, 0xE0U, 0xDDU, 0xA7U, 0x53U, 0xA6U, 0x51U, + 0xA2U, 0x59U, 0xB2U, 0x79U, 0xF2U, 0xF9U, 0xEFU, 0xC3U, 0x9BU, 0x2BU, 0x56U, 0xACU, 0x45U, 0x8AU, 0x09U, 0x12U, + 0x24U, 0x48U, 0x90U, 0x3DU, 0x7AU, 0xF4U, 0xF5U, 0xF7U, 0xF3U, 0xFBU, 0xEBU, 0xCBU, 0x8BU, 0x0BU, 0x16U, 0x2CU, + 0x58U, 0xB0U, 0x7DU, 0xFAU, 0xE9U, 0xCFU, 0x83U, 0x1BU, 0x36U, 0x6CU, 0xD8U, 0xADU, 0x47U, 0x8EU, 0x01U, 0x00U}; + +const unsigned char LOG_TABLE[] = { + 0x00U, 0x00U, 0x01U, 0x19U, 0x02U, 0x32U, 0x1AU, 0xC6U, 0x03U, 0xDFU, 0x33U, 0xEEU, 0x1BU, 0x68U, 0xC7U, 0x4BU, + 0x04U, 0x64U, 0xE0U, 0x0EU, 0x34U, 0x8DU, 0xEFU, 0x81U, 0x1CU, 0xC1U, 0x69U, 0xF8U, 0xC8U, 0x08U, 0x4CU, 0x71U, + 0x05U, 0x8AU, 0x65U, 0x2FU, 0xE1U, 0x24U, 0x0FU, 0x21U, 0x35U, 0x93U, 0x8EU, 0xDAU, 0xF0U, 0x12U, 0x82U, 0x45U, + 0x1DU, 0xB5U, 0xC2U, 0x7DU, 0x6AU, 0x27U, 0xF9U, 0xB9U, 0xC9U, 0x9AU, 0x09U, 0x78U, 0x4DU, 0xE4U, 0x72U, 0xA6U, + 0x06U, 0xBFU, 0x8BU, 0x62U, 0x66U, 0xDDU, 0x30U, 0xFDU, 0xE2U, 0x98U, 0x25U, 0xB3U, 0x10U, 0x91U, 0x22U, 0x88U, + 0x36U, 0xD0U, 0x94U, 0xCEU, 0x8FU, 0x96U, 0xDBU, 0xBDU, 0xF1U, 0xD2U, 0x13U, 0x5CU, 0x83U, 0x38U, 0x46U, 0x40U, + 0x1EU, 0x42U, 0xB6U, 0xA3U, 0xC3U, 0x48U, 0x7EU, 0x6EU, 0x6BU, 0x3AU, 0x28U, 0x54U, 0xFAU, 0x85U, 0xBAU, 0x3DU, + 0xCAU, 0x5EU, 0x9BU, 0x9FU, 0x0AU, 0x15U, 0x79U, 0x2BU, 0x4EU, 0xD4U, 0xE5U, 0xACU, 0x73U, 0xF3U, 0xA7U, 0x57U, + 0x07U, 0x70U, 0xC0U, 0xF7U, 0x8CU, 0x80U, 0x63U, 0x0DU, 0x67U, 0x4AU, 0xDEU, 0xEDU, 0x31U, 0xC5U, 0xFEU, 0x18U, + 0xE3U, 0xA5U, 0x99U, 0x77U, 0x26U, 0xB8U, 0xB4U, 0x7CU, 0x11U, 0x44U, 0x92U, 0xD9U, 0x23U, 0x20U, 0x89U, 0x2EU, + 0x37U, 0x3FU, 0xD1U, 0x5BU, 0x95U, 0xBCU, 0xCFU, 0xCDU, 0x90U, 0x87U, 0x97U, 0xB2U, 0xDCU, 0xFCU, 0xBEU, 0x61U, + 0xF2U, 0x56U, 0xD3U, 0xABU, 0x14U, 0x2AU, 0x5DU, 0x9EU, 0x84U, 0x3CU, 0x39U, 0x53U, 0x47U, 0x6DU, 0x41U, 0xA2U, + 0x1FU, 0x2DU, 0x43U, 0xD8U, 0xB7U, 0x7BU, 0xA4U, 0x76U, 0xC4U, 0x17U, 0x49U, 0xECU, 0x7FU, 0x0CU, 0x6FU, 0xF6U, + 0x6CU, 0xA1U, 0x3BU, 0x52U, 0x29U, 0x9DU, 0x55U, 0xAAU, 0xFBU, 0x60U, 0x86U, 0xB1U, 0xBBU, 0xCCU, 0x3EU, 0x5AU, + 0xCBU, 0x59U, 0x5FU, 0xB0U, 0x9CU, 0xA9U, 0xA0U, 0x51U, 0x0BU, 0xF5U, 0x16U, 0xEBU, 0x7AU, 0x75U, 0x2CU, 0xD7U, + 0x4FU, 0xAEU, 0xD5U, 0xE9U, 0xE6U, 0xE7U, 0xADU, 0xE8U, 0x74U, 0xD6U, 0xF4U, 0xEAU, 0xA8U, 0x50U, 0x58U, 0xAFU}; + +/* multiplication using logarithms */ +static unsigned char gmult(unsigned char a, unsigned char b) +{ + if (a == 0U || b == 0U) + return 0U; + + unsigned int i = LOG_TABLE[a]; + unsigned int j = LOG_TABLE[b]; + + return EXP_TABLE[i + j]; +} + +/* Simulate a LFSR with generator polynomial for n byte RS code. + * Pass in a pointer to the data array, and amount of data. + * + * The parity bytes are deposited into parity. + */ +void CRS129::encode(const unsigned char* msg, unsigned int nbytes, unsigned char* parity) +{ + assert(msg != NULL); + assert(parity != NULL); + + for (unsigned int i = 0U; i < NPAR + 1U; i++) + parity[i] = 0x00U; + + for (unsigned int i = 0U; i < nbytes; i++) { + unsigned char dbyte = msg[i] ^ parity[NPAR - 1U]; + + for (int j = NPAR - 1; j > 0; j--) + parity[j] = parity[j - 1] ^ ::gmult(POLY[j], dbyte); + + parity[0] = ::gmult(POLY[0], dbyte); + } +} + +// Reed-Solomon (12,9) check +bool CRS129::check(const unsigned char* in) +{ + assert(in != NULL); + + unsigned char parity[4U]; + encode(in, 9U, parity); + + return in[9U] == parity[2U] && in[10U] == parity[1U] && in[11U] == parity[0U]; +} + diff --git a/RS129.h b/RS129.h new file mode 100644 index 0000000..60f99bd --- /dev/null +++ b/RS129.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(RS129_H) +#define RS129_H + +class CRS129 +{ +public: + static bool check(const unsigned char* in); + + static void encode(const unsigned char* msg, unsigned int nbytes, unsigned char* parity); +}; + +#endif diff --git a/RingBuffer.h b/RingBuffer.h new file mode 100644 index 0000000..07d4798 --- /dev/null +++ b/RingBuffer.h @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2006-2009,2012,2013,2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef RingBuffer_H +#define RingBuffer_H + +#include +#include + +template class CRingBuffer { +public: + CRingBuffer(unsigned int length) : + m_length(length), + m_buffer(NULL), + m_iPtr(0U), + m_oPtr(0U) + { + assert(length > 0U); + + m_buffer = new T[length]; + + ::memset(m_buffer, 0x00, m_length * sizeof(T)); + } + + ~CRingBuffer() + { + delete[] m_buffer; + } + + unsigned int addData(const T* buffer, unsigned int nSamples) + { + if (nSamples > freeSpace()) + return 0U; + + for (unsigned int i = 0U; i < nSamples; i++) { + m_buffer[m_iPtr++] = buffer[i]; + + if (m_iPtr == m_length) + m_iPtr = 0U; + } + + return nSamples; + } + + unsigned int getData(T* buffer, unsigned int nSamples) + { + unsigned int data = dataSize(); + + if (data < nSamples) + nSamples = data; + + for (unsigned int i = 0U; i < nSamples; i++) { + buffer[i] = m_buffer[m_oPtr++]; + + if (m_oPtr == m_length) + m_oPtr = 0U; + } + + return nSamples; + } + + unsigned int peek(T* buffer, unsigned int nSamples) + { + unsigned int data = dataSize(); + + if (data < nSamples) + nSamples = data; + + unsigned int ptr = m_oPtr; + for (unsigned int i = 0U; i < nSamples; i++) { + buffer[i] = m_buffer[ptr++]; + + if (ptr == m_length) + ptr = 0U; + } + + return nSamples; + } + + void clear() + { + m_iPtr = 0U; + m_oPtr = 0U; + + ::memset(m_buffer, 0x00, m_length * sizeof(T)); + } + + unsigned int freeSpace() const + { + if (m_oPtr == m_iPtr) + return m_length - 1U; + + if (m_oPtr > m_iPtr) + return m_oPtr - m_iPtr - 1U; + + return m_length - (m_iPtr - m_oPtr) - 1U; + } + + bool hasSpace(unsigned int length) const + { + return freeSpace() > length; + } + + bool hasData() const + { + return m_oPtr != m_iPtr; + } + + bool isEmpty() const + { + return m_oPtr == m_iPtr; + } + +private: + unsigned int m_length; + T* m_buffer; + volatile unsigned int m_iPtr; + volatile unsigned int m_oPtr; + + unsigned int dataSize() const + { + if (m_iPtr >= m_oPtr) + return m_iPtr - m_oPtr; + + return m_length - (m_oPtr - m_iPtr); + } +}; + +#endif diff --git a/SHA256.cpp b/SHA256.cpp new file mode 100644 index 0000000..b3366e0 --- /dev/null +++ b/SHA256.cpp @@ -0,0 +1,373 @@ +/* + * Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc. + * Copyright (C) 2011,2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "SHA256.h" + +#include +#include +#include + +#ifdef WORDS_BIGENDIAN +# define SWAP(n) (n) +#else +# define SWAP(n) \ + (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24)) +#endif + +#define BLOCKSIZE 4096 +#if BLOCKSIZE % 64 != 0 +# error "invalid BLOCKSIZE" +#endif + +/* This array contains the bytes used to pad the buffer to the next + 64-byte boundary. */ +static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; + + +/* + Takes a pointer to a 256 bit block of data (eight 32 bit ints) and + intializes it to the start constants of the SHA256 algorithm. This + must be called before using hash in the call to sha256_hash +*/ +CSHA256::CSHA256() : +m_state(NULL), +m_total(NULL), +m_buflen(0U), +m_buffer(NULL) +{ + m_state = new uint32_t[8U]; + m_total = new uint32_t[2U]; + m_buffer = new uint32_t[32U]; + + init(); +} + +CSHA256::~CSHA256() +{ + delete[] m_state; + delete[] m_total; + delete[] m_buffer; +} + +void CSHA256::init() +{ + m_state[0] = 0x6a09e667UL; + m_state[1] = 0xbb67ae85UL; + m_state[2] = 0x3c6ef372UL; + m_state[3] = 0xa54ff53aUL; + m_state[4] = 0x510e527fUL; + m_state[5] = 0x9b05688cUL; + m_state[6] = 0x1f83d9abUL; + m_state[7] = 0x5be0cd19UL; + + m_total[0] = m_total[1] = 0; + m_buflen = 0; +} + +/* Copy the value from v into the memory location pointed to by *cp, + If your architecture allows unaligned access this is equivalent to + * (uint32_t *) cp = v */ +static inline void set_uint32(unsigned char* cp, uint32_t v) +{ + assert(cp != NULL); + + ::memcpy(cp, &v, sizeof v); +} + +/* Put result from CTX in first 32 bytes following RESBUF. The result + must be in little endian byte order. */ +unsigned char* CSHA256::read(unsigned char* resbuf) +{ + assert(resbuf != NULL); + + for (unsigned int i = 0U; i < 8U; i++) + set_uint32(resbuf + i * sizeof(m_state[0]), SWAP(m_state[i])); + + return resbuf; +} + +/* Process the remaining bytes in the internal buffer and the usual + prolog according to the standard and write the result to RESBUF. */ +void CSHA256::conclude() +{ + /* Take yet unprocessed bytes into account. */ + unsigned int bytes = m_buflen; + unsigned int size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4; + + /* Now count remaining bytes. */ + m_total[0] += bytes; + if (m_total[0] < bytes) + ++m_total[1]; + + /* Put the 64-bit file length in *bits* at the end of the buffer. + Use set_uint32 rather than a simple assignment, to avoid risk of + unaligned access. */ + set_uint32((unsigned char*)&m_buffer[size - 2], SWAP((m_total[1] << 3) | (m_total[0] >> 29))); + set_uint32((unsigned char*)&m_buffer[size - 1], SWAP(m_total[0] << 3)); + + ::memcpy(&((char*)m_buffer)[bytes], fillbuf, (size - 2) * 4 - bytes); + + /* Process last bytes. */ + processBlock((unsigned char*)m_buffer, size * 4); +} + +unsigned char* CSHA256::finish(unsigned char* resbuf) +{ + assert(resbuf != NULL); + + conclude(); + + return read(resbuf); +} + +/* Compute SHA256 message digest for LEN bytes beginning at BUFFER. The + result is always in little endian byte order, so that a byte-wise + output yields to the wanted ASCII representation of the message + digest. */ +unsigned char* CSHA256::buffer(const unsigned char* buffer, unsigned int len, unsigned char* resblock) +{ + assert(buffer != NULL); + assert(resblock != NULL); + + /* Initialize the computation context. */ + init(); + + /* Process whole buffer but last len % 64 bytes. */ + processBytes(buffer, len); + + /* Put result in desired memory area. */ + return finish(resblock); +} + +void CSHA256::processBytes(const unsigned char* buffer, unsigned int len) +{ + assert(buffer != NULL); + + /* When we already have some bits in our internal buffer concatenate + both inputs first. */ + if (m_buflen != 0U) { + unsigned int left_over = m_buflen; + unsigned int add = 128U - left_over > len ? len : 128U - left_over; + + ::memcpy(&((char*)m_buffer)[left_over], buffer, add); + m_buflen += add; + + if (m_buflen > 64U) { + processBlock((unsigned char*)m_buffer, m_buflen & ~63U); + + m_buflen &= 63U; + + /* The regions in the following copy operation cannot overlap. */ + ::memcpy(m_buffer, &((char*)m_buffer)[(left_over + add) & ~63U], m_buflen); + } + + buffer += add; + len -= add; + } + + /* Process available complete blocks. */ + if (len >= 64U) { +//#if !_STRING_ARCH_unaligned +//# define alignof(type) offsetof (struct { char c; type x; }, x) +//# define UNALIGNED_P(p) (((unsigned int) p) % alignof (uint32_t) != 0) +// if (UNALIGNED_P (buffer)) { +// while (len > 64U) { +// ::memcpy(m_buffer, buffer, 64U); +// processBlock((unsigned char*)m_buffer, 64U); +// buffer += 64U; +// len -= 64U; +// } +// } else +//#endif + { + processBlock(buffer, len & ~63U); + buffer += (len & ~63U); + len &= 63U; + } + } + + /* Move remaining bytes in internal buffer. */ + if (len > 0U) { + unsigned int left_over = m_buflen; + + ::memcpy(&((char*)m_buffer)[left_over], buffer, len); + left_over += len; + + if (left_over >= 64U) { + processBlock((unsigned char*)m_buffer, 64U); + left_over -= 64U; + ::memcpy(m_buffer, &m_buffer[16], left_over); + } + + m_buflen = left_over; + } +} + +/* --- Code below is the primary difference between sha1.c and sha256.c --- */ + +/* SHA256 round constants */ +#define K(I) roundConstants[I] +static const uint32_t roundConstants[64] = { + 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, + 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, + 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL, + 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, + 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, + 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, + 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, + 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL, + 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL, + 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, + 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, + 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, + 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, + 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL, + 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, + 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL, +}; + +/* Round functions. */ +#define F2(A,B,C) ( ( A & B ) | ( C & ( A | B ) ) ) +#define F1(E,F,G) ( G ^ ( E & ( F ^ G ) ) ) + +/* Process LEN bytes of BUFFER, accumulating context into CTX. + It is assumed that LEN % 64 == 0. + Most of this code comes from GnuPG's cipher/sha1.c. */ + +void CSHA256::processBlock(const unsigned char* buffer, unsigned int len) +{ + assert(buffer != NULL); + + const uint32_t* words = (uint32_t*)buffer; + unsigned int nwords = len / sizeof(uint32_t); + const uint32_t* endp = words + nwords; + uint32_t x[16]; + uint32_t a = m_state[0]; + uint32_t b = m_state[1]; + uint32_t c = m_state[2]; + uint32_t d = m_state[3]; + uint32_t e = m_state[4]; + uint32_t f = m_state[5]; + uint32_t g = m_state[6]; + uint32_t h = m_state[7]; + + /* First increment the byte count. FIPS PUB 180-2 specifies the possible + length of the file up to 2^64 bits. Here we only compute the + number of bytes. Do a double word increment. */ + m_total[0] += len; + if (m_total[0] < len) + ++m_total[1]; + + #define rol(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + #define S0(x) (rol(x,25)^rol(x,14)^(x>>3)) + #define S1(x) (rol(x,15)^rol(x,13)^(x>>10)) + #define SS0(x) (rol(x,30)^rol(x,19)^rol(x,10)) + #define SS1(x) (rol(x,26)^rol(x,21)^rol(x,7)) + + #define M(I) (tm = S1(x[(I-2)&0x0f]) + x[(I-7)&0x0f] + S0(x[(I-15)&0x0f]) + x[I&0x0f], x[I&0x0f] = tm) + + #define R(A,B,C,D,E,F,G,H,K,M) do { t0 = SS0(A) + F2(A,B,C); \ + t1 = H + SS1(E) + F1(E,F,G) + K + M; \ + D += t1; H = t0 + t1; \ + } while(0) + + while (words < endp) { + uint32_t tm; + uint32_t t0, t1; + /* FIXME: see sha1.c for a better implementation. */ + for (unsigned int t = 0U; t < 16U; t++) { + x[t] = SWAP(*words); + words++; + } + + R( a, b, c, d, e, f, g, h, K( 0), x[ 0] ); + R( h, a, b, c, d, e, f, g, K( 1), x[ 1] ); + R( g, h, a, b, c, d, e, f, K( 2), x[ 2] ); + R( f, g, h, a, b, c, d, e, K( 3), x[ 3] ); + R( e, f, g, h, a, b, c, d, K( 4), x[ 4] ); + R( d, e, f, g, h, a, b, c, K( 5), x[ 5] ); + R( c, d, e, f, g, h, a, b, K( 6), x[ 6] ); + R( b, c, d, e, f, g, h, a, K( 7), x[ 7] ); + R( a, b, c, d, e, f, g, h, K( 8), x[ 8] ); + R( h, a, b, c, d, e, f, g, K( 9), x[ 9] ); + R( g, h, a, b, c, d, e, f, K(10), x[10] ); + R( f, g, h, a, b, c, d, e, K(11), x[11] ); + R( e, f, g, h, a, b, c, d, K(12), x[12] ); + R( d, e, f, g, h, a, b, c, K(13), x[13] ); + R( c, d, e, f, g, h, a, b, K(14), x[14] ); + R( b, c, d, e, f, g, h, a, K(15), x[15] ); + R( a, b, c, d, e, f, g, h, K(16), M(16) ); + R( h, a, b, c, d, e, f, g, K(17), M(17) ); + R( g, h, a, b, c, d, e, f, K(18), M(18) ); + R( f, g, h, a, b, c, d, e, K(19), M(19) ); + R( e, f, g, h, a, b, c, d, K(20), M(20) ); + R( d, e, f, g, h, a, b, c, K(21), M(21) ); + R( c, d, e, f, g, h, a, b, K(22), M(22) ); + R( b, c, d, e, f, g, h, a, K(23), M(23) ); + R( a, b, c, d, e, f, g, h, K(24), M(24) ); + R( h, a, b, c, d, e, f, g, K(25), M(25) ); + R( g, h, a, b, c, d, e, f, K(26), M(26) ); + R( f, g, h, a, b, c, d, e, K(27), M(27) ); + R( e, f, g, h, a, b, c, d, K(28), M(28) ); + R( d, e, f, g, h, a, b, c, K(29), M(29) ); + R( c, d, e, f, g, h, a, b, K(30), M(30) ); + R( b, c, d, e, f, g, h, a, K(31), M(31) ); + R( a, b, c, d, e, f, g, h, K(32), M(32) ); + R( h, a, b, c, d, e, f, g, K(33), M(33) ); + R( g, h, a, b, c, d, e, f, K(34), M(34) ); + R( f, g, h, a, b, c, d, e, K(35), M(35) ); + R( e, f, g, h, a, b, c, d, K(36), M(36) ); + R( d, e, f, g, h, a, b, c, K(37), M(37) ); + R( c, d, e, f, g, h, a, b, K(38), M(38) ); + R( b, c, d, e, f, g, h, a, K(39), M(39) ); + R( a, b, c, d, e, f, g, h, K(40), M(40) ); + R( h, a, b, c, d, e, f, g, K(41), M(41) ); + R( g, h, a, b, c, d, e, f, K(42), M(42) ); + R( f, g, h, a, b, c, d, e, K(43), M(43) ); + R( e, f, g, h, a, b, c, d, K(44), M(44) ); + R( d, e, f, g, h, a, b, c, K(45), M(45) ); + R( c, d, e, f, g, h, a, b, K(46), M(46) ); + R( b, c, d, e, f, g, h, a, K(47), M(47) ); + R( a, b, c, d, e, f, g, h, K(48), M(48) ); + R( h, a, b, c, d, e, f, g, K(49), M(49) ); + R( g, h, a, b, c, d, e, f, K(50), M(50) ); + R( f, g, h, a, b, c, d, e, K(51), M(51) ); + R( e, f, g, h, a, b, c, d, K(52), M(52) ); + R( d, e, f, g, h, a, b, c, K(53), M(53) ); + R( c, d, e, f, g, h, a, b, K(54), M(54) ); + R( b, c, d, e, f, g, h, a, K(55), M(55) ); + R( a, b, c, d, e, f, g, h, K(56), M(56) ); + R( h, a, b, c, d, e, f, g, K(57), M(57) ); + R( g, h, a, b, c, d, e, f, K(58), M(58) ); + R( f, g, h, a, b, c, d, e, K(59), M(59) ); + R( e, f, g, h, a, b, c, d, K(60), M(60) ); + R( d, e, f, g, h, a, b, c, K(61), M(61) ); + R( c, d, e, f, g, h, a, b, K(62), M(62) ); + R( b, c, d, e, f, g, h, a, K(63), M(63) ); + + a = m_state[0] += a; + b = m_state[1] += b; + c = m_state[2] += c; + d = m_state[3] += d; + e = m_state[4] += e; + f = m_state[5] += f; + g = m_state[6] += g; + h = m_state[7] += h; + } +} diff --git a/SHA256.h b/SHA256.h new file mode 100644 index 0000000..24d7be5 --- /dev/null +++ b/SHA256.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc. + * Copyright (C) 2011,2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef SHA256_H +#define SHA256_H + +#if defined(WIN32) +typedef unsigned int uint32_t; +#else +#include +#endif + +enum { + SHA256_DIGEST_SIZE = 256 / 8 +}; + +class CSHA256 { +public: + CSHA256(); + ~CSHA256(); + + /* Starting with the result of former calls of this function (or the + initialization function update the context for the next LEN bytes + starting at BUFFER. + It is necessary that LEN is a multiple of 64!!! */ + void processBlock(const unsigned char* buffer, unsigned int len); + + /* Starting with the result of former calls of this function (or the + initialization function update the context for the next LEN bytes + starting at BUFFER. + It is NOT required that LEN is a multiple of 64. */ + void processBytes(const unsigned char* buffer, unsigned int len); + + /* Process the remaining bytes in the buffer and put result from CTX + in first 32 bytes following RESBUF. The result is always in little + endian byte order, so that a byte-wise output yields to the wanted + ASCII representation of the message digest. */ + unsigned char* finish(unsigned char* resbuf); + + /* Put result from CTX in first 32 bytes following RESBUF. The result is + always in little endian byte order, so that a byte-wise output yields + to the wanted ASCII representation of the message digest. */ + unsigned char* read(unsigned char* resbuf); + + /* Compute SHA256 message digest for LEN bytes beginning at BUFFER. The + result is always in little endian byte order, so that a byte-wise + output yields to the wanted ASCII representation of the message + digest. */ + unsigned char* buffer(const unsigned char* buffer, unsigned int len, unsigned char* resblock); + +private: + uint32_t* m_state; + uint32_t* m_total; + unsigned int m_buflen; + uint32_t* m_buffer; + + void init(); + void conclude(); +}; + +#endif diff --git a/SerialController.cpp b/SerialController.cpp new file mode 100644 index 0000000..25a6eaf --- /dev/null +++ b/SerialController.cpp @@ -0,0 +1,467 @@ +/* + * Copyright (C) 2002-2004,2007-2011,2013,2014,2015 by Jonathan Naylor G4KLX + * Copyright (C) 1999-2001 by Thomas Sailor HB9JNX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "SerialController.h" +#include "Log.h" + +#include + +#include + +#if defined(WIN32) +#include +#include +#else +#include +#include +#include +#include +#include +#include +#endif + + +#if defined(WIN32) + +const unsigned int BUFFER_LENGTH = 1000U; + +CSerialController::CSerialController(const std::string& device, SERIAL_SPEED speed, bool assertRTS) : +m_device(device), +m_speed(speed), +m_assertRTS(assertRTS), +m_handle(INVALID_HANDLE_VALUE), +m_readOverlapped(), +m_writeOverlapped(), +m_readBuffer(NULL), +m_readLength(0U), +m_readPending(false) +{ + assert(!device.empty()); + + m_readBuffer = new unsigned char[BUFFER_LENGTH]; +} + +CSerialController::~CSerialController() +{ + delete[] m_readBuffer; +} + +bool CSerialController::open() +{ + assert(m_handle == INVALID_HANDLE_VALUE); + + DWORD errCode; + + std::string baseName = m_device.substr(4U); // Convert "\\.\COM10" to "COM10" + + m_handle = ::CreateFileA(m_device.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); + if (m_handle == INVALID_HANDLE_VALUE) { + LogError("Cannot open device - %s, err=%04lx", m_device.c_str(), ::GetLastError()); + return false; + } + + DCB dcb; + if (::GetCommState(m_handle, &dcb) == 0) { + LogError("Cannot get the attributes for %s, err=%04lx", m_device.c_str(), ::GetLastError()); + ::ClearCommError(m_handle, &errCode, NULL); + ::CloseHandle(m_handle); + return false; + } + + dcb.BaudRate = DWORD(m_speed); + dcb.ByteSize = 8; + dcb.Parity = NOPARITY; + dcb.fParity = FALSE; + dcb.StopBits = ONESTOPBIT; + dcb.fInX = FALSE; + dcb.fOutX = FALSE; + dcb.fOutxCtsFlow = FALSE; + dcb.fOutxDsrFlow = FALSE; + dcb.fDtrControl = DTR_CONTROL_DISABLE; + dcb.fRtsControl = RTS_CONTROL_DISABLE; + + if (::SetCommState(m_handle, &dcb) == 0) { + LogError("Cannot set the attributes for %s, err=%04lx", m_device.c_str(), ::GetLastError()); + ::ClearCommError(m_handle, &errCode, NULL); + ::CloseHandle(m_handle); + return false; + } + + COMMTIMEOUTS timeouts; + if (!::GetCommTimeouts(m_handle, &timeouts)) { + LogError("Cannot get the timeouts for %s, err=%04lx", m_device.c_str(), ::GetLastError()); + ::ClearCommError(m_handle, &errCode, NULL); + ::CloseHandle(m_handle); + return false; + } + + timeouts.ReadIntervalTimeout = MAXDWORD; + timeouts.ReadTotalTimeoutMultiplier = 0UL; + timeouts.ReadTotalTimeoutConstant = 0UL; + + if (!::SetCommTimeouts(m_handle, &timeouts)) { + LogError("Cannot set the timeouts for %s, err=%04lx", m_device.c_str(), ::GetLastError()); + ::ClearCommError(m_handle, &errCode, NULL); + ::CloseHandle(m_handle); + return false; + } + + if (::EscapeCommFunction(m_handle, CLRDTR) == 0) { + LogError("Cannot clear DTR for %s, err=%04lx", m_device.c_str(), ::GetLastError()); + ::ClearCommError(m_handle, &errCode, NULL); + ::CloseHandle(m_handle); + return false; + } + + if (::EscapeCommFunction(m_handle, m_assertRTS ? SETRTS : CLRRTS) == 0) { + LogError("Cannot set/clear RTS for %s, err=%04lx", m_device.c_str(), ::GetLastError()); + ::ClearCommError(m_handle, &errCode, NULL); + ::CloseHandle(m_handle); + return false; + } + + ::ClearCommError(m_handle, &errCode, NULL); + + ::memset(&m_readOverlapped, 0x00U, sizeof(OVERLAPPED)); + ::memset(&m_writeOverlapped, 0x00U, sizeof(OVERLAPPED)); + + m_readOverlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); + m_writeOverlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); + + m_readLength = 0U; + m_readPending = false; + ::memset(m_readBuffer, 0x00U, BUFFER_LENGTH); + + return true; +} + +int CSerialController::read(unsigned char* buffer, unsigned int length) +{ + assert(m_handle != INVALID_HANDLE_VALUE); + assert(buffer != NULL); + + unsigned int ptr = 0U; + + while (ptr < length) { + int ret = readNonblock(buffer + ptr, length - ptr); + if (ret < 0) { + return ret; + } else if (ret == 0) { + if (ptr == 0U) + return 0; + } else { + ptr += ret; + } + } + + return int(length); +} + +int CSerialController::readNonblock(unsigned char* buffer, unsigned int length) +{ + assert(m_handle != INVALID_HANDLE_VALUE); + assert(buffer != NULL); + + if (length > BUFFER_LENGTH) + length = BUFFER_LENGTH; + + if (m_readPending && length != m_readLength) { + ::CancelIo(m_handle); + m_readPending = false; + } + + m_readLength = length; + + if (length == 0U) + return 0; + + if (!m_readPending) { + DWORD bytes = 0UL; + BOOL res = ::ReadFile(m_handle, m_readBuffer, m_readLength, &bytes, &m_readOverlapped); + if (res) { + ::memcpy(buffer, m_readBuffer, bytes); + return int(bytes); + } + + DWORD error = ::GetLastError(); + if (error != ERROR_IO_PENDING) { + LogError("Error from ReadFile: %04lx", error); + return -1; + } + + m_readPending = true; + } + + BOOL res = HasOverlappedIoCompleted(&m_readOverlapped); + if (!res) + return 0; + + DWORD bytes = 0UL; + res = ::GetOverlappedResult(m_handle, &m_readOverlapped, &bytes, TRUE); + if (!res) { + LogError("Error from GetOverlappedResult (ReadFile): %04lx", ::GetLastError()); + return -1; + } + + ::memcpy(buffer, m_readBuffer, bytes); + m_readPending = false; + + return int(bytes); +} + +int CSerialController::write(const unsigned char* buffer, unsigned int length) +{ + assert(m_handle != INVALID_HANDLE_VALUE); + assert(buffer != NULL); + + if (length == 0U) + return 0; + + unsigned int ptr = 0U; + + while (ptr < length) { + DWORD bytes = 0UL; + BOOL res = ::WriteFile(m_handle, buffer + ptr, length - ptr, &bytes, &m_writeOverlapped); + if (!res) { + DWORD error = ::GetLastError(); + if (error != ERROR_IO_PENDING) { + LogError("Error from WriteFile: %04lx", error); + return -1; + } + + res = ::GetOverlappedResult(m_handle, &m_writeOverlapped, &bytes, TRUE); + if (!res) { + LogError("Error from GetOverlappedResult (WriteFile): %04lx", ::GetLastError()); + return -1; + } + } + + ptr += bytes; + } + + return int(length); +} + +void CSerialController::close() +{ + assert(m_handle != INVALID_HANDLE_VALUE); + + ::CloseHandle(m_handle); + m_handle = INVALID_HANDLE_VALUE; + + ::CloseHandle(m_readOverlapped.hEvent); + ::CloseHandle(m_writeOverlapped.hEvent); +} + +#else + +CSerialController::CSerialController(const std::string& device, SERIAL_SPEED speed, bool assertRTS) : +m_device(device), +m_speed(speed), +m_assertRTS(assertRTS), +m_fd(-1) +{ + assert(!device.empty()); +} + +CSerialController::~CSerialController() +{ +} + +bool CSerialController::open() +{ + assert(m_fd == -1); + + m_fd = ::open(m_device.c_str(), O_RDWR | O_NOCTTY | O_NDELAY, 0); + if (m_fd < 0) { + LogError("Cannot open device - %s", m_device.c_str()); + return false; + } + + if (::isatty(m_fd) == 0) { + LogError("%s is not a TTY device", m_device.c_str()); + ::close(m_fd); + return false; + } + + termios termios; + if (::tcgetattr(m_fd, &termios) < 0) { + LogError("Cannot get the attributes for %s", m_device.c_str()); + ::close(m_fd); + return false; + } + + termios.c_lflag &= ~(ECHO | ECHOE | ICANON | IEXTEN | ISIG); + termios.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON | IXOFF | IXANY); + termios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CRTSCTS); + termios.c_cflag |= CS8; + termios.c_oflag &= ~(OPOST); + termios.c_cc[VMIN] = 0; + termios.c_cc[VTIME] = 10; + + switch (m_speed) { + case SERIAL_1200: + ::cfsetospeed(&termios, B1200); + ::cfsetispeed(&termios, B1200); + break; + case SERIAL_2400: + ::cfsetospeed(&termios, B2400); + ::cfsetispeed(&termios, B2400); + break; + case SERIAL_4800: + ::cfsetospeed(&termios, B4800); + ::cfsetispeed(&termios, B4800); + break; + case SERIAL_9600: + ::cfsetospeed(&termios, B9600); + ::cfsetispeed(&termios, B9600); + break; + case SERIAL_19200: + ::cfsetospeed(&termios, B19200); + ::cfsetispeed(&termios, B19200); + break; + case SERIAL_38400: + ::cfsetospeed(&termios, B38400); + ::cfsetispeed(&termios, B38400); + break; + case SERIAL_115200: + ::cfsetospeed(&termios, B115200); + ::cfsetispeed(&termios, B115200); + break; + case SERIAL_230400: + ::cfsetospeed(&termios, B230400); + ::cfsetispeed(&termios, B230400); + break; + default: + LogError("Unsupported serial port speed - %d", int(m_speed)); + ::close(m_fd); + return false; + } + + if (::tcsetattr(m_fd, TCSANOW, &termios) < 0) { + LogError("Cannot set the attributes for %s", m_device.c_str()); + ::close(m_fd); + return false; + } + + if (m_assertRTS) { + unsigned int y; + if (::ioctl(m_fd, TIOCMGET, &y) < 0) { + LogError("Cannot get the control attributes for %s", m_device.c_str()); + ::close(m_fd); + return false; + } + + y |= TIOCM_RTS; + + if (::ioctl(m_fd, TIOCMSET, &y) < 0) { + LogError("Cannot set the control attributes for %s", m_device.c_str()); + ::close(m_fd); + return false; + } + } + + return true; +} + +int CSerialController::read(unsigned char* buffer, unsigned int length) +{ + assert(buffer != NULL); + assert(m_fd != -1); + + if (length == 0U) + return 0; + + unsigned int offset = 0U; + + while (offset < length) { + fd_set fds; + FD_ZERO(&fds); + FD_SET(m_fd, &fds); + + int n; + if (offset == 0U) { + struct timeval tv; + tv.tv_sec = 0; + tv.tv_usec = 0; + + n = ::select(m_fd + 1, &fds, NULL, NULL, &tv); + if (n == 0) + return 0; + } else { + n = ::select(m_fd + 1, &fds, NULL, NULL, NULL); + } + + if (n < 0) { + LogError("Error from select(), errno=%d", errno); + return -1; + } + + if (n > 0) { + ssize_t len = ::read(m_fd, buffer + offset, length - offset); + if (len < 0) { + if (errno != EAGAIN) { + LogError("Error from read(), errno=%d", errno); + return -1; + } + } + + if (len > 0) + offset += len; + } + } + + return length; +} + +int CSerialController::write(const unsigned char* buffer, unsigned int length) +{ + assert(buffer != NULL); + assert(m_fd != -1); + + if (length == 0U) + return 0; + + unsigned int ptr = 0U; + + while (ptr < length) { + ssize_t n = ::write(m_fd, buffer + ptr, length - ptr); + if (n < 0) { + if (errno != EAGAIN) { + LogError("Error returned from write(), errno=%d", errno); + return -1; + } + } + + if (n > 0) + ptr += n; + } + + return length; +} + +void CSerialController::close() +{ + assert(m_fd != -1); + + ::close(m_fd); + m_fd = -1; +} + +#endif diff --git a/SerialController.h b/SerialController.h new file mode 100644 index 0000000..ade0ad6 --- /dev/null +++ b/SerialController.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2002-2004,2007-2009,2011-2013,2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 1999-2001 by Thomas Sailor HB9JNX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef SerialController_H +#define SerialController_H + +#include + +#if defined(_WIN32) || defined(_WIN64) +#include +#endif + +enum SERIAL_SPEED { + SERIAL_1200 = 1200, + SERIAL_2400 = 2400, + SERIAL_4800 = 4800, + SERIAL_9600 = 9600, + SERIAL_19200 = 19200, + SERIAL_38400 = 38400, + SERIAL_76800 = 76800, + SERIAL_115200 = 115200, + SERIAL_230400 = 230400 +}; + +class CSerialController { +public: + CSerialController(const std::string& device, SERIAL_SPEED speed, bool assertRTS = false); + ~CSerialController(); + + bool open(); + + int read(unsigned char* buffer, unsigned int length); + int write(const unsigned char* buffer, unsigned int length); + + void close(); + +private: + std::string m_device; + SERIAL_SPEED m_speed; + bool m_assertRTS; +#if defined(_WIN32) || defined(_WIN64) + HANDLE m_handle; + OVERLAPPED m_readOverlapped; + OVERLAPPED m_writeOverlapped; + unsigned char* m_readBuffer; + unsigned int m_readLength; + bool m_readPending; +#else + int m_fd; +#endif + +#if defined(_WIN32) || defined(_WIN64) + int readNonblock(unsigned char* buffer, unsigned int length); +#endif +}; + +#endif diff --git a/ShortLC.cpp b/ShortLC.cpp new file mode 100644 index 0000000..8b6c56a --- /dev/null +++ b/ShortLC.cpp @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "ShortLC.h" + +#include "Hamming.h" +#include "Utils.h" + +#include +#include +#include + +CShortLC::CShortLC() : +m_rawData(NULL), +m_deInterData(NULL) +{ + m_rawData = new bool[72U]; + m_deInterData = new bool[68U]; +} + +CShortLC::~CShortLC() +{ + delete[] m_rawData; + delete[] m_deInterData; +} + +// The main decode function +bool CShortLC::decode(const unsigned char* in, unsigned char* out) +{ + assert(in != NULL); + assert(out != NULL); + + // Get the raw binary + decodeExtractBinary(in); + + // Deinterleave + decodeDeInterleave(); + + // Error check + bool ret = decodeErrorCheck(); + if (!ret) + return false; + + // Extract Data + decodeExtractData(out); + + return true; +} + +// The main encode function +void CShortLC::encode(const unsigned char* in, unsigned char* out) +{ + assert(in != NULL); + assert(out != NULL); + + // Extract Data + encodeExtractData(in); + + // Error check + encodeErrorCheck(); + + // Deinterleave + encodeInterleave(); + + // Get the raw binary + encodeExtractBinary(out); +} + +void CShortLC::decodeExtractBinary(const unsigned char* in) +{ + CUtils::byteToBitsBE(in[0U], m_rawData + 0U); + CUtils::byteToBitsBE(in[1U], m_rawData + 8U); + CUtils::byteToBitsBE(in[2U], m_rawData + 16U); + CUtils::byteToBitsBE(in[3U], m_rawData + 24U); + CUtils::byteToBitsBE(in[4U], m_rawData + 32U); + CUtils::byteToBitsBE(in[5U], m_rawData + 40U); + CUtils::byteToBitsBE(in[6U], m_rawData + 48U); + CUtils::byteToBitsBE(in[7U], m_rawData + 56U); + CUtils::byteToBitsBE(in[8U], m_rawData + 64U); +} + +// Deinterleave the raw data +void CShortLC::decodeDeInterleave() +{ + for (unsigned int i = 0U; i < 68U; i++) + m_deInterData[i] = false; + + for (unsigned int a = 0U; a < 67U; a++) { + // Calculate the interleave sequence + unsigned int interleaveSequence = (a * 4U) % 67U; + // Shuffle the data + m_deInterData[a] = m_rawData[interleaveSequence]; + } + + m_deInterData[67U] = m_rawData[67U]; +} + +// Check each row with a Hamming (17,12,3) code and each column with a parity bit +bool CShortLC::decodeErrorCheck() +{ + // Run through each of the 3 rows containing data + CHamming::decode17123(m_deInterData + 0U); + CHamming::decode17123(m_deInterData + 17U); + CHamming::decode17123(m_deInterData + 34U); + + // Run through each of the 17 columns + for (unsigned int c = 0U; c < 17U; c++) { + bool bit = m_deInterData[c + 0U] ^ m_deInterData[c + 17U] ^ m_deInterData[c + 34U]; + if (bit != m_deInterData[c + 51U]) + return false; + } + + return true; +} + +// Extract the 36 bits of payload +void CShortLC::decodeExtractData(unsigned char* data) const +{ + bool bData[40U]; + + for (unsigned int i = 0U; i < 40U; i++) + bData[i] = false; + + unsigned int pos = 4U; + for (unsigned int a = 0U; a < 12U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 17U; a < 29U; a++, pos++) + bData[pos] = m_deInterData[a]; + + for (unsigned int a = 34U; a < 46U; a++, pos++) + bData[pos] = m_deInterData[a]; + + CUtils::bitsToByteBE(bData + 0U, data[0U]); + CUtils::bitsToByteBE(bData + 8U, data[1U]); + CUtils::bitsToByteBE(bData + 16U, data[2U]); + CUtils::bitsToByteBE(bData + 24U, data[3U]); + CUtils::bitsToByteBE(bData + 32U, data[4U]); +} + +// Extract the 36 bits of payload +void CShortLC::encodeExtractData(const unsigned char* in) const +{ + bool bData[40U]; + CUtils::byteToBitsBE(in[0U], bData + 0U); + CUtils::byteToBitsBE(in[1U], bData + 8U); + CUtils::byteToBitsBE(in[2U], bData + 16U); + CUtils::byteToBitsBE(in[3U], bData + 24U); + CUtils::byteToBitsBE(in[4U], bData + 32U); + + for (unsigned int i = 0U; i < 68U; i++) + m_deInterData[i] = false; + + unsigned int pos = 4U; + for (unsigned int a = 0U; a < 12U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 17U; a < 29U; a++, pos++) + m_deInterData[a] = bData[pos]; + + for (unsigned int a = 34U; a < 46U; a++, pos++) + m_deInterData[a] = bData[pos]; +} + +// Check each row with a Hamming (17,12,3) code and each column with a parity bit +void CShortLC::encodeErrorCheck() +{ + // Run through each of the 3 rows containing data + CHamming::encode17123(m_deInterData + 0U); + CHamming::encode17123(m_deInterData + 17U); + CHamming::encode17123(m_deInterData + 34U); + + // Run through each of the 17 columns + for (unsigned int c = 0U; c < 17U; c++) + m_deInterData[c + 51U] = m_deInterData[c + 0U] ^ m_deInterData[c + 17U] ^ m_deInterData[c + 34U]; +} + +// Interleave the raw data +void CShortLC::encodeInterleave() +{ + for (unsigned int i = 0U; i < 72U; i++) + m_rawData[i] = false; + + for (unsigned int a = 0U; a < 67U; a++) { + // Calculate the interleave sequence + unsigned int interleaveSequence = (a * 4U) % 67U; + // Unshuffle the data + m_rawData[interleaveSequence] = m_deInterData[a]; + } + + m_rawData[67U] = m_deInterData[67U]; +} + +void CShortLC::encodeExtractBinary(unsigned char* data) +{ + CUtils::bitsToByteBE(m_rawData + 0U, data[0U]); + CUtils::bitsToByteBE(m_rawData + 8U, data[1U]); + CUtils::bitsToByteBE(m_rawData + 16U, data[2U]); + CUtils::bitsToByteBE(m_rawData + 24U, data[3U]); + CUtils::bitsToByteBE(m_rawData + 32U, data[4U]); + CUtils::bitsToByteBE(m_rawData + 40U, data[5U]); + CUtils::bitsToByteBE(m_rawData + 48U, data[6U]); + CUtils::bitsToByteBE(m_rawData + 56U, data[7U]); + CUtils::bitsToByteBE(m_rawData + 64U, data[8U]); +} diff --git a/ShortLC.h b/ShortLC.h new file mode 100644 index 0000000..04e69a5 --- /dev/null +++ b/ShortLC.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(SHORTLC_H) +#define SHORTLC_H + +class CShortLC +{ +public: + CShortLC(); + ~CShortLC(); + + bool decode(const unsigned char* in, unsigned char* out); + + void encode(const unsigned char* in, unsigned char* out); + +private: + bool* m_rawData; + bool* m_deInterData; + + void decodeExtractBinary(const unsigned char* in); + bool decodeErrorCheck(); + void decodeDeInterleave(); + void decodeExtractData(unsigned char* data) const; + + void encodeExtractData(const unsigned char* in) const; + void encodeInterleave(); + void encodeErrorCheck(); + void encodeExtractBinary(unsigned char* data); +}; + +#endif diff --git a/SlotType.cpp b/SlotType.cpp new file mode 100644 index 0000000..2319ba6 --- /dev/null +++ b/SlotType.cpp @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "SlotType.h" + +#include "Golay2087.h" + +#include +#include + +CSlotType::CSlotType() : +m_colorCode(0U), +m_dataType(0U) +{ +} + +CSlotType::~CSlotType() +{ +} + +void CSlotType::putData(const unsigned char* data) +{ + assert(data != NULL); + + unsigned char slotType[3U]; + slotType[0U] = (data[12U] << 2) & 0xFCU; + slotType[0U] |= (data[13U] >> 6) & 0x03U; + + slotType[1U] = (data[13U] << 2) & 0xC0U; + slotType[1U] |= (data[19U] << 2) & 0x3CU; + slotType[1U] |= (data[20U] >> 6) & 0x03U; + + slotType[2U] = (data[20U] << 2) & 0xF0U; + + unsigned char code = CGolay2087::decode(slotType); + + m_colorCode = (code >> 4) & 0x0FU; + m_dataType = (code >> 0) & 0x0FU; +} + +void CSlotType::getData(unsigned char* data) const +{ + assert(data != NULL); + + unsigned char slotType[3U]; + slotType[0U] = (m_colorCode << 4) & 0xF0U; + slotType[0U] |= (m_dataType << 0) & 0x0FU; + slotType[1U] = 0x00U; + slotType[2U] = 0x00U; + + CGolay2087::encode(slotType); + + data[12U] = (data[12U] & 0xC0U) | ((slotType[0U] >> 2) & 0x3FU); + data[13U] = (data[13U] & 0x0FU) | ((slotType[0U] << 6) & 0xC0U) | ((slotType[1U] >> 2) & 0x30U); + data[19U] = (data[19U] & 0xF0U) | ((slotType[1U] >> 2) & 0x0FU); + data[20U] = (data[20U] & 0x03U) | ((slotType[1U] << 6) & 0xC0U) | ((slotType[2U] >> 2) & 0x3CU); +} + +unsigned char CSlotType::getColorCode() const +{ + return m_colorCode; +} + +void CSlotType::setColorCode(unsigned char code) +{ + m_colorCode = code; +} + +unsigned char CSlotType::getDataType() const +{ + return m_dataType; +} + +void CSlotType::setDataType(unsigned char type) +{ + m_dataType = type; +} diff --git a/SlotType.h b/SlotType.h new file mode 100644 index 0000000..07440df --- /dev/null +++ b/SlotType.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(SLOTTYPE_H) +#define SLOTTYPE_H + +class CSlotType +{ +public: + CSlotType(); + ~CSlotType(); + + void putData(const unsigned char* data); + void getData(unsigned char* data) const; + + unsigned char getColorCode() const; + void setColorCode(unsigned char code); + + unsigned char getDataType() const; + void setDataType(unsigned char type); + +private: + unsigned char m_colorCode; + unsigned char m_dataType; +}; + +#endif diff --git a/StopWatch.cpp b/StopWatch.cpp new file mode 100644 index 0000000..beb4bbe --- /dev/null +++ b/StopWatch.cpp @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "StopWatch.h" + +#if defined(_WIN32) || defined(_WIN64) + +CStopWatch::CStopWatch() : +m_frequency(), +m_start() +{ + ::QueryPerformanceFrequency(&m_frequency); +} + +CStopWatch::~CStopWatch() +{ +} + +unsigned long CStopWatch::start() +{ + ::QueryPerformanceCounter(&m_start); + + return (unsigned long)(m_start.QuadPart / m_frequency.QuadPart); +} + +unsigned int CStopWatch::elapsed() +{ + LARGE_INTEGER now; + ::QueryPerformanceCounter(&now); + + LARGE_INTEGER temp; + temp.QuadPart = (now.QuadPart - m_start.QuadPart) * 1000; + + return (unsigned int)(temp.QuadPart / m_frequency.QuadPart); +} + +#else + +CStopWatch::CStopWatch() : +m_start() +{ +} + +CStopWatch::~CStopWatch() +{ +} + +unsigned long CStopWatch::start() +{ + ::clock_gettime(CLOCK_MONOTONIC, &m_start); + + return m_start.tv_nsec; +} + +unsigned int CStopWatch::elapsed() +{ + timespec now; + ::clock_gettime(CLOCK_MONOTONIC, &now); + + if (m_start.tv_sec == now.tv_sec) { + return (now.tv_nsec - m_start.tv_nsec) / 1000000U; + } else { + long temp = -m_start.tv_nsec / 1000000L; + temp += (now.tv_sec - m_start.tv_sec) * 1000L; + temp += m_start.tv_nsec / 1000000L; + return temp; + } +} + +#endif diff --git a/StopWatch.h b/StopWatch.h new file mode 100644 index 0000000..645664c --- /dev/null +++ b/StopWatch.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(STOPWATCH_H) +#define STOPWATCH_H + +#if defined(_WIN32) || defined(_WIN64) +#include +#else +#include +#endif + +class CStopWatch +{ +public: + CStopWatch(); + ~CStopWatch(); + + unsigned long start(); + unsigned int elapsed(); + +private: +#if defined(WIN32) + LARGE_INTEGER m_frequency; + LARGE_INTEGER m_start; +#else + timespec m_start; +#endif +}; + +#endif diff --git a/TFTSerial.cpp b/TFTSerial.cpp new file mode 100644 index 0000000..00d1257 --- /dev/null +++ b/TFTSerial.cpp @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "TFTSerial.h" +#include "Log.h" + +CTFTSerial::CTFTSerial(const std::string& port) : +m_serial(port, SERIAL_9600) +{ +} + +CTFTSerial::~CTFTSerial() +{ +} + +bool CTFTSerial::open() +{ + bool ret = m_serial.open(); + if (!ret) { + LogError("Cannot open the port for the TFT Serial"); + return false; + } + + // Set background white + m_serial.write((unsigned char*)"\x1B\x02\x07\xFF", 4U); + + // Set foreground black + m_serial.write((unsigned char*)"\x1B\x01\x00\xFF", 4U); + + setIdle(); + + return true; +} + +void CTFTSerial::setIdle() +{ + // Clear the screen + m_serial.write((unsigned char*)"\x1B\x00\xFF", 3U); + + // Draw MMDVM logo + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00MMDVM_sm.bmp\xFF", 15U); + + // Draw all mode insignias + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00ALL_sm.bmp\xFF", 15U); +} + +void CTFTSerial::setDStar() +{ + // Clear the screen + m_serial.write((unsigned char*)"\x1B\x00\xFF", 3U); + + // Draw MMDVM logo + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00MMDVM_sm.bmp\xFF", 15U); + + // Draw D-Star insignia + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00DStar_sm.bmp\xFF", 17U); + + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + m_serial.write((unsigned char*)"Listening", 9U); +} + +void CTFTSerial::writeDStar(const std::string& call1, const std::string& call2) +{ + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + + char text[20U]; + ::sprintf(text, "%s/%s", call1.c_str(), call2.c_str()); + + m_serial.write((unsigned char*)text, ::strlen(text)); +} + +void CTFTSerial::clearDStar() +{ + // Draw MMDVM logo + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00MMDVM_sm.bmp\xFF", 15U); + + // Draw D-Star insignia + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00DStar_sm.bmp\xFF", 17U); + + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + m_serial.write((unsigned char*)"Listening", 9U); +} + +void CTFTSerial::setDMR() +{ + // Clear the screen + m_serial.write((unsigned char*)"\x1B\x00\xFF", 3U); + + // Draw MMDVM logo + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00MMDVM_sm.bmp\xFF", 15U); + + // Draw DMR insignia + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00DMR_sm.bmp\xFF", 15U); + + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + m_serial.write((unsigned char*)"1: Listening", 9U); + + m_serial.write((unsigned char*)"\x1B\x06\x00\x09\xFF", 5U); + m_serial.write((unsigned char*)"2: Listening", 9U); +} + +void CTFTSerial::writeDMR(unsigned int slotNo, unsigned int srcId, bool group, unsigned int dstId) +{ + char text[20U]; + ::sprintf(text, "%u: %u %s%u", slotNo, srcId, group ? "TG " : "", dstId); + + if (slotNo == 1U) + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + else + m_serial.write((unsigned char*)"\x1B\x06\x00\x09\xFF", 5U); + + m_serial.write((unsigned char*)text, ::strlen(text)); +} + +void CTFTSerial::clearDMR(unsigned int slotNo) +{ + if (slotNo == 1U) { + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + m_serial.write((unsigned char*)"1: Listening", 11U); + } else { + m_serial.write((unsigned char*)"\x1B\x06\x00\x09\xFF", 5U); + m_serial.write((unsigned char*)"2: Listening", 11U); + } +} + +void CTFTSerial::setFusion() +{ + // Clear the screen + m_serial.write((unsigned char*)"\x1B\x00\xFF", 3U); + + // Draw MMDVM logo + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00MMDVM_sm.bmp\xFF", 15U); + + // Draw the System Fusion insignia + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00YSF_sm.bmp\xFF", 15U); + + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + m_serial.write((unsigned char*)"Listening", 9U); +} + +void CTFTSerial::writeFusion(const std::string& callsign) +{ + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + + char text[20U]; + ::sprintf(text, "%s", callsign.c_str()); + + m_serial.write((unsigned char*)text, ::strlen(text)); +} + +void CTFTSerial::clearFusion() +{ + // Draw MMDVM logo + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00MMDVM_sm.bmp\xFF", 15U); + + // Draw the System Fusion insignia + m_serial.write((unsigned char*)"\x1B\x0D\x00\x00YSF_sm.bmp\xFF", 15U); + + m_serial.write((unsigned char*)"\x1B\x06\x00\x08\xFF", 5U); + m_serial.write((unsigned char*)"Listening", 9U); +} + +void CTFTSerial::close() +{ + m_serial.close(); +} diff --git a/TFTSerial.h b/TFTSerial.h new file mode 100644 index 0000000..4a88a78 --- /dev/null +++ b/TFTSerial.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(TFTSERIAL_H) +#define TFTSERIAL_H + +#include "Display.h" +#include "SerialController.h" + +#include + +class CTFTSerial : public IDisplay +{ +public: + CTFTSerial(const std::string& port); + virtual ~CTFTSerial(); + + virtual bool open(); + + virtual void setIdle(); + + virtual void setDStar(); + virtual void writeDStar(const std::string& call1, const std::string& call2); + virtual void clearDStar(); + + virtual void setDMR(); + virtual void writeDMR(unsigned int slotNo, unsigned int srdId, bool group, unsigned int dstId); + virtual void clearDMR(unsigned int slotNo); + + virtual void setFusion(); + virtual void writeFusion(const std::string& callsign); + virtual void clearFusion(); + + virtual void close(); + +private: + CSerialController m_serial; +}; + +#endif diff --git a/Timer.cpp b/Timer.cpp new file mode 100644 index 0000000..53956e4 --- /dev/null +++ b/Timer.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2009,2010,2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "Timer.h" + +#include +#include + +CTimer::CTimer(unsigned int ticksPerSec, unsigned int secs, unsigned int msecs) : +m_ticksPerSec(ticksPerSec), +m_timeout(0U), +m_timer(0U) +{ + assert(ticksPerSec > 0U); + + if (secs > 0U || msecs > 0U) { + // m_timeout = ((secs * 1000U + msecs) * m_ticksPerSec) / 1000U + 1U; + unsigned long long temp = (secs * 1000ULL + msecs) * m_ticksPerSec; + m_timeout = (unsigned int)(temp / 1000ULL + 1ULL); + } +} + +CTimer::~CTimer() +{ +} + +void CTimer::setTimeout(unsigned int secs, unsigned int msecs) +{ + if (secs > 0U || msecs > 0U) { + // m_timeout = ((secs * 1000U + msecs) * m_ticksPerSec) / 1000U + 1U; + unsigned long long temp = (secs * 1000ULL + msecs) * m_ticksPerSec; + m_timeout = (unsigned int)(temp / 1000ULL + 1ULL); + } else { + m_timeout = 0U; + m_timer = 0U; + } +} + +unsigned int CTimer::getTimeout() const +{ + if (m_timeout == 0U) + return 0U; + + return (m_timeout - 1U) / m_ticksPerSec; +} + +unsigned int CTimer::getTimer() const +{ + if (m_timer == 0U) + return 0U; + + return (m_timer - 1U) / m_ticksPerSec; +} diff --git a/Timer.h b/Timer.h new file mode 100644 index 0000000..87d68f5 --- /dev/null +++ b/Timer.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2009,2010,2011,2014 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef Timer_H +#define Timer_H + +class CTimer { +public: + CTimer(unsigned int ticksPerSec, unsigned int secs = 0U, unsigned int msecs = 0U); + ~CTimer(); + + void setTimeout(unsigned int secs, unsigned int msecs = 0U); + + unsigned int getTimeout() const; + unsigned int getTimer() const; + + unsigned int getRemaining() + { + if (m_timeout == 0U || m_timer == 0U) + return 0U; + + if (m_timer >= m_timeout) + return 0U; + + return (m_timeout - m_timer) / m_ticksPerSec; + } + + bool isRunning() + { + return m_timer > 0U; + } + + void start(unsigned int secs, unsigned int msecs = 0U) + { + setTimeout(secs, msecs); + + start(); + } + + void start() + { + if (m_timeout > 0U) + m_timer = 1U; + } + + void stop() + { + m_timer = 0U; + } + + bool hasExpired() + { + if (m_timeout == 0U || m_timer == 0U) + return false; + + if (m_timer >= m_timeout) + return true; + + return false; + } + + void clock(unsigned int ticks = 1U) + { + if (m_timer > 0U && m_timeout > 0U) + m_timer += ticks; + } + +private: + unsigned int m_ticksPerSec; + unsigned int m_timeout; + unsigned int m_timer; +}; + +#endif diff --git a/UDPSocket.cpp b/UDPSocket.cpp new file mode 100644 index 0000000..281f73a --- /dev/null +++ b/UDPSocket.cpp @@ -0,0 +1,263 @@ +/* + * Copyright (C) 2006-2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "UDPSocket.h" +#include "Log.h" + +#include + +#if !defined(_WIN32) && !defined(_WIN64) +#include +#include +#endif + + +CUDPSocket::CUDPSocket(const std::string& address, unsigned int port) : +m_address(address), +m_port(port), +m_fd(-1) +{ + assert(!address.empty()); + assert(port > 0U); + +#if defined(_WIN32) || defined(_WIN64) + WSAData data; + int wsaRet = ::WSAStartup(MAKEWORD(2, 2), &data); + if (wsaRet != 0) + LogError("Error from WSAStartup"); +#endif +} + +CUDPSocket::CUDPSocket() : +m_address(), +m_port(0U), +m_fd(-1) +{ +#if defined(_WIN32) || defined(_WIN64) + WSAData data; + int wsaRet = ::WSAStartup(MAKEWORD(2, 2), &data); + if (wsaRet != 0) + LogError("Error from WSAStartup"); +#endif +} + +CUDPSocket::~CUDPSocket() +{ +#if defined(_WIN32) || defined(_WIN64) + ::WSACleanup(); +#endif +} + +in_addr CUDPSocket::lookup(const std::string& hostname) +{ + in_addr addr; +#if defined(_WIN32) || defined(_WIN64) + unsigned long address = ::inet_addr(hostname.c_str()); + if (address != INADDR_NONE && address != INADDR_ANY) { + addr.s_addr = address; + return addr; + } + + struct hostent* hp = ::gethostbyname(hostname.c_str()); + if (hp != NULL) { + ::memcpy(&addr, hp->h_addr_list[0], sizeof(struct in_addr)); + return addr; + } + + LogError("Cannot find address for host %s", hostname.c_str()); + + addr.s_addr = INADDR_NONE; + return addr; +#else + in_addr_t address = ::inet_addr(hostname.c_str()); + if (address != in_addr_t(-1)) { + addr.s_addr = address; + return addr; + } + + struct hostent* hp = ::gethostbyname(hostname.c_str()); + if (hp != NULL) { + ::memcpy(&addr, hp->h_addr_list[0], sizeof(struct in_addr)); + return addr; + } + + LogError("Cannot find address for host %s", hostname.c_str()); + + addr.s_addr = INADDR_NONE; + return addr; +#endif +} + +bool CUDPSocket::open() +{ + m_fd = ::socket(PF_INET, SOCK_DGRAM, 0); + if (m_fd < 0) { +#if defined(_WIN32) || defined(_WIN64) + LogError("Cannot create the UDP socket, err: %lu", ::GetLastError()); +#else + LogError("Cannot create the UDP socket, err: %d", errno); +#endif + return false; + } + + if (m_port > 0U) { + sockaddr_in addr; + ::memset(&addr, 0x00, sizeof(sockaddr_in)); + addr.sin_family = AF_INET; + addr.sin_port = htons(m_port); + addr.sin_addr.s_addr = htonl(INADDR_ANY); + + if (!m_address.empty()) { +#if defined(_WIN32) || defined(_WIN64) + addr.sin_addr.s_addr = ::inet_addr(m_address.c_str()); +#else + addr.sin_addr.s_addr = ::inet_addr(m_address.c_str()); +#endif + if (addr.sin_addr.s_addr == INADDR_NONE) { + LogError("The local address is invalid - %s", m_address.c_str()); + return false; + } + } + + int reuse = 1; + if (::setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse)) == -1) { +#if defined(_WIN32) || defined(_WIN64) + LogError("Cannot set the UDP socket option, err: %lu", ::GetLastError()); +#else + LogError("Cannot set the UDP socket option, err: %d", errno); +#endif + return false; + } + + if (::bind(m_fd, (sockaddr*)&addr, sizeof(sockaddr_in)) == -1) { +#if defined(_WIN32) || defined(_WIN64) + LogError("Cannot bind the UDP address, err: %lu", ::GetLastError()); +#else + LogError("Cannot bind the UDP address, err: %d", errno); +#endif + return false; + } + } + + return true; +} + +int CUDPSocket::read(unsigned char* buffer, unsigned int length, in_addr& address, unsigned int& port) +{ + assert(buffer != NULL); + assert(length > 0U); + + // Check that the readfrom() won't block + fd_set readFds; + FD_ZERO(&readFds); +#if defined(_WIN32) || defined(_WIN64) + FD_SET((unsigned int)m_fd, &readFds); +#else + FD_SET(m_fd, &readFds); +#endif + + // Return immediately + timeval tv; + tv.tv_sec = 0L; + tv.tv_usec = 0L; + + int ret = ::select(m_fd + 1, &readFds, NULL, NULL, &tv); + if (ret < 0) { +#if defined(_WIN32) || defined(_WIN64) + LogError("Error returned from UDP select, err: %lu", ::GetLastError()); +#else + LogError("Error returned from UDP select, err: %d", errno); +#endif + return -1; + } + + if (ret == 0) + return 0; + + sockaddr_in addr; +#if defined(_WIN32) || defined(_WIN64) + int size = sizeof(sockaddr_in); +#else + socklen_t size = sizeof(sockaddr_in); +#endif + +#if defined(_WIN32) || defined(_WIN64) + int len = ::recvfrom(m_fd, (char*)buffer, length, 0, (sockaddr *)&addr, &size); +#else + ssize_t len = ::recvfrom(m_fd, (char*)buffer, length, 0, (sockaddr *)&addr, &size); +#endif + if (len <= 0) { +#if defined(_WIN32) || defined(_WIN64) + LogError("Error returned from recvfrom, err: %lu", ::GetLastError()); +#else + LogError("Error returned from recvfrom, err: %d", errno); +#endif + return -1; + } + + address = addr.sin_addr; + port = ntohs(addr.sin_port); + + return len; +} + +bool CUDPSocket::write(const unsigned char* buffer, unsigned int length, const in_addr& address, unsigned int port) +{ + assert(buffer != NULL); + assert(length > 0U); + + sockaddr_in addr; + ::memset(&addr, 0x00, sizeof(sockaddr_in)); + + addr.sin_family = AF_INET; + addr.sin_addr = address; + addr.sin_port = htons(port); + +#if defined(_WIN32) || defined(_WIN64) + int ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&addr, sizeof(sockaddr_in)); +#else + ssize_t ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&addr, sizeof(sockaddr_in)); +#endif + if (ret < 0) { +#if defined(_WIN32) || defined(_WIN64) + LogError("Error returned from sendto, err: %lu", ::GetLastError()); +#else + LogError("Error returned from sendto, err: %d", errno); +#endif + return false; + } + +#if defined(_WIN32) || defined(_WIN64) + if (ret != int(length)) + return false; +#else + if (ret != ssize_t(length)) + return false; +#endif + + return true; +} + +void CUDPSocket::close() +{ +#if defined(_WIN32) || defined(_WIN64) + ::closesocket(m_fd); +#else + ::close(m_fd); +#endif +} diff --git a/UDPSocket.h b/UDPSocket.h new file mode 100644 index 0000000..1d06ee2 --- /dev/null +++ b/UDPSocket.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009-2011,2013,2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef UDPSocket_H +#define UDPSocket_H + +#include + +#if !defined(_WIN32) && !defined(_WIN64) +#include +#include +#include +#include +#include +#include +#include +#include +#else +#include +#endif + +class CUDPSocket { +public: + CUDPSocket(const std::string& address, unsigned int port); + CUDPSocket(); + ~CUDPSocket(); + + bool open(); + + int read(unsigned char* buffer, unsigned int length, in_addr& address, unsigned int& port); + bool write(const unsigned char* buffer, unsigned int length, const in_addr& address, unsigned int port); + + void close(); + + static in_addr lookup(const std::string& hostName); + +private: + std::string m_address; + unsigned short m_port; + int m_fd; +}; + +#endif diff --git a/Utils.cpp b/Utils.cpp new file mode 100644 index 0000000..52d9063 --- /dev/null +++ b/Utils.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2009,2014,2015 Jonathan Naylor, G4KLX + * + * 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; version 2 of the License. + * + * 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. + */ + +#include "Utils.h" +#include "Log.h" + +#include +#include + +void CUtils::dump(const std::string& title, const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + + dump(2U, title, data, length); +} + +void CUtils::dump(int level, const std::string& title, const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + + ::Log(level, "%s", title.c_str()); + + unsigned int offset = 0U; + + while (length > 0U) { + std::string output; + + unsigned int bytes = (length > 16U) ? 16U : length; + + for (unsigned i = 0U; i < bytes; i++) { + char temp[10U]; + ::sprintf(temp, "%02X ", data[offset + i]); + output += temp; + } + + for (unsigned int i = bytes; i < 16U; i++) + output += " "; + + output += " *"; + + for (unsigned i = 0U; i < bytes; i++) { + unsigned char c = data[offset + i]; + + if (::isprint(c)) + output += c; + else + output += '.'; + } + + output += '*'; + + ::Log(level, "%04X: %s", offset, output.c_str()); + + offset += 16U; + + if (length >= 16U) + length -= 16U; + else + length = 0U; + } +} + +void CUtils::dump(const std::string& title, const bool* bits, unsigned int length) +{ + assert(bits != NULL); + + dump(2U, title, bits, length); +} + +void CUtils::dump(int level, const std::string& title, const bool* bits, unsigned int length) +{ + assert(bits != NULL); + + unsigned char bytes[100U]; + unsigned int nBytes = 0U; + for (unsigned int n = 0U; n < length; n += 8U, nBytes++) + bitsToByteBE(bits + n, bytes[nBytes]); + + dump(level, title, bytes, nBytes); +} + +void CUtils::byteToBitsBE(unsigned char byte, bool* bits) +{ + bits[0U] = (byte & 0x80U) == 0x80U; + bits[1U] = (byte & 0x40U) == 0x40U; + bits[2U] = (byte & 0x20U) == 0x20U; + bits[3U] = (byte & 0x10U) == 0x10U; + bits[4U] = (byte & 0x08U) == 0x08U; + bits[5U] = (byte & 0x04U) == 0x04U; + bits[6U] = (byte & 0x02U) == 0x02U; + bits[7U] = (byte & 0x01U) == 0x01U; +} + +void CUtils::byteToBitsLE(unsigned char byte, bool* bits) +{ + bits[0U] = (byte & 0x01U) == 0x01U; + bits[1U] = (byte & 0x02U) == 0x02U; + bits[2U] = (byte & 0x04U) == 0x04U; + bits[3U] = (byte & 0x08U) == 0x08U; + bits[4U] = (byte & 0x10U) == 0x10U; + bits[5U] = (byte & 0x20U) == 0x20U; + bits[6U] = (byte & 0x40U) == 0x40U; + bits[7U] = (byte & 0x80U) == 0x80U; +} + +void CUtils::bitsToByteBE(const bool* bits, unsigned char& byte) +{ + byte = bits[0U] ? 0x80U : 0x00U; + byte |= bits[1U] ? 0x40U : 0x00U; + byte |= bits[2U] ? 0x20U : 0x00U; + byte |= bits[3U] ? 0x10U : 0x00U; + byte |= bits[4U] ? 0x08U : 0x00U; + byte |= bits[5U] ? 0x04U : 0x00U; + byte |= bits[6U] ? 0x02U : 0x00U; + byte |= bits[7U] ? 0x01U : 0x00U; +} + +void CUtils::bitsToByteLE(const bool* bits, unsigned char& byte) +{ + byte = bits[0U] ? 0x01U : 0x00U; + byte |= bits[1U] ? 0x02U : 0x00U; + byte |= bits[2U] ? 0x04U : 0x00U; + byte |= bits[3U] ? 0x08U : 0x00U; + byte |= bits[4U] ? 0x10U : 0x00U; + byte |= bits[5U] ? 0x20U : 0x00U; + byte |= bits[6U] ? 0x40U : 0x00U; + byte |= bits[7U] ? 0x80U : 0x00U; +} diff --git a/Utils.h b/Utils.h new file mode 100644 index 0000000..ade28c0 --- /dev/null +++ b/Utils.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2009,2014,2015 by Jonathan Naylor, G4KLX + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef Utils_H +#define Utils_H + +#include + +class CUtils { +public: + static void dump(const std::string& title, const unsigned char* data, unsigned int length); + static void dump(int level, const std::string& title, const unsigned char* data, unsigned int length); + + static void dump(const std::string& title, const bool* bits, unsigned int length); + static void dump(int level, const std::string& title, const bool* bits, unsigned int length); + + static void byteToBitsBE(unsigned char byte, bool* bits); + static void byteToBitsLE(unsigned char byte, bool* bits); + + static void bitsToByteBE(const bool* bits, unsigned char& byte); + static void bitsToByteLE(const bool* bits, unsigned char& byte); + +private: +}; + +#endif diff --git a/Version.h b/Version.h new file mode 100644 index 0000000..0ea15c9 --- /dev/null +++ b/Version.h @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(VERSION_H) +#define VERSION_H + +const char* VERSION = "20160113"; + +#endif diff --git a/YSFDefines.h b/YSFDefines.h new file mode 100644 index 0000000..f713e5b --- /dev/null +++ b/YSFDefines.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(YSFDefines_H) +#define YSFDefines_H + +const unsigned int YSF_FRAME_LENGTH_BYTES = 120U; + +const unsigned char YSF_SYNC_BYTES[] = {0xD4U, 0x71U, 0xC9U, 0x63U, 0x4DU}; + +const unsigned char YSF_FI_MASK = 0xC0U; +const unsigned char YSF_DT_MASK = 0x30U; + +const unsigned char YSF_DT_TERMINATOR_CHANNEL = 0x80U; + +const unsigned char YSF_CKSUM_OK = 0x01U; + +#endif diff --git a/YSFEcho.cpp b/YSFEcho.cpp new file mode 100644 index 0000000..5bcf54f --- /dev/null +++ b/YSFEcho.cpp @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "YSFEcho.h" + +#include "YSFDefines.h" + +CYSFEcho::CYSFEcho(unsigned int delay, unsigned int space) : +m_buffer(space), +m_timer(1000U, delay) +{ +} + +CYSFEcho::~CYSFEcho() +{ +} + +unsigned int CYSFEcho::readData(unsigned char* data) +{ + if (!hasData()) + return 0U; + + unsigned char len; + m_buffer.getData(&len, 1U); + + m_buffer.getData(data, len); + + // If the FICH is valid, regenerate the sync + if ((data[1U] & 0x01U) == 0x01U) { + data[2U] = YSF_SYNC_BYTES[0U]; + data[3U] = YSF_SYNC_BYTES[1U]; + data[4U] = YSF_SYNC_BYTES[2U]; + data[5U] = YSF_SYNC_BYTES[3U]; + data[6U] = YSF_SYNC_BYTES[4U]; + } + + if (!hasData()) + m_timer.stop(); + + return len; +} + +bool CYSFEcho::writeData(const unsigned char* data, unsigned int length) +{ + bool ret = m_buffer.hasSpace(length + 1U); + if (!ret) + return false; + + unsigned char len = length; + m_buffer.addData(&len, 1U); + + m_buffer.addData(data, length); + + m_timer.start(); + + return true; +} + +bool CYSFEcho::hasData() +{ + if (m_timer.isRunning() && m_timer.hasExpired()) + return m_buffer.hasData(); + else + return false; +} + +void CYSFEcho::clock(unsigned int ms) +{ + m_timer.clock(ms); +} diff --git a/YSFEcho.h b/YSFEcho.h new file mode 100644 index 0000000..3218a6e --- /dev/null +++ b/YSFEcho.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2015 by Jonathan Naylor G4KLX + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#if !defined(YSFECHO_H) +#define YSFECHO_H + +#include "RingBuffer.h" +#include "Timer.h" + +class CYSFEcho { +public: + CYSFEcho(unsigned int delay, unsigned int space); + ~CYSFEcho(); + + unsigned int readData(unsigned char* data); + + bool writeData(const unsigned char* data, unsigned int length); + + bool hasData(); + + void clock(unsigned int ms); + +private: + CRingBuffer m_buffer; + CTimer m_timer; +}; + +#endif