From cb5198ff752755e4afe6aaccd6c3e43afcadb83b Mon Sep 17 00:00:00 2001 From: Doug McLain Date: Mon, 2 Nov 2020 00:11:30 -0500 Subject: [PATCH] Add DMR2M17 --- DMR2M17/BPTC19696.cpp | 347 ++++++ DMR2M17/BPTC19696.h | 47 + DMR2M17/CRC.cpp | 254 +++++ DMR2M17/CRC.h | 40 + DMR2M17/Conf.cpp | 272 +++++ DMR2M17/Conf.h | 96 ++ DMR2M17/DMR2M17.cpp | 694 ++++++++++++ DMR2M17/DMR2M17.h | 84 ++ DMR2M17/DMR2M17.ini | 29 + DMR2M17/DMRData.cpp | 211 ++++ DMR2M17/DMRData.h | 78 ++ DMR2M17/DMRDefines.h | 122 +++ DMR2M17/DMREMB.cpp | 100 ++ DMR2M17/DMREMB.h | 46 + DMR2M17/DMREmbeddedData.cpp | 322 ++++++ DMR2M17/DMREmbeddedData.h | 63 ++ DMR2M17/DMRFullLC.cpp | 99 ++ DMR2M17/DMRFullLC.h | 42 + DMR2M17/DMRLC.cpp | 205 ++++ DMR2M17/DMRLC.h | 62 ++ DMR2M17/DMRLookup.cpp | 179 +++ DMR2M17/DMRLookup.h | 56 + DMR2M17/DMRSlotType.cpp | 92 ++ DMR2M17/DMRSlotType.h | 42 + DMR2M17/Defines.h | 69 ++ DMR2M17/DelayBuffer.cpp | 159 +++ DMR2M17/DelayBuffer.h | 58 + DMR2M17/Golay2087.cpp | 262 +++++ DMR2M17/Golay2087.h | 32 + DMR2M17/Golay24128.cpp | 1108 +++++++++++++++++++ DMR2M17/Golay24128.h | 32 + DMR2M17/Hamming.cpp | 349 ++++++ DMR2M17/Hamming.h | 43 + DMR2M17/LICENSE | 340 ++++++ DMR2M17/Log.cpp | 136 +++ DMR2M17/Log.h | 36 + DMR2M17/M17Network.cpp | 129 +++ DMR2M17/M17Network.h | 47 + DMR2M17/MBEVocoder.cpp | 41 + DMR2M17/MBEVocoder.h | 35 + DMR2M17/MMDVMNetwork.cpp | 342 ++++++ DMR2M17/MMDVMNetwork.h | 76 ++ DMR2M17/Makefile | 26 + DMR2M17/ModeConv.cpp | 781 +++++++++++++ DMR2M17/ModeConv.h | 59 + DMR2M17/Mutex.cpp | 65 ++ DMR2M17/Mutex.h | 45 + DMR2M17/QR1676.cpp | 115 ++ DMR2M17/QR1676.h | 32 + DMR2M17/README.md | 28 + DMR2M17/RS129.cpp | 127 +++ DMR2M17/RS129.h | 30 + DMR2M17/RingBuffer.h | 154 +++ DMR2M17/SHA256.cpp | 373 +++++++ DMR2M17/SHA256.h | 73 ++ DMR2M17/StopWatch.cpp | 105 ++ DMR2M17/StopWatch.h | 49 + DMR2M17/Sync.cpp | 53 + DMR2M17/Sync.h | 32 + DMR2M17/Thread.cpp | 101 ++ DMR2M17/Thread.h | 56 + DMR2M17/Timer.cpp | 68 ++ DMR2M17/Timer.h | 89 ++ DMR2M17/UDPSocket.cpp | 212 ++++ DMR2M17/UDPSocket.h | 54 + DMR2M17/Utils.cpp | 146 +++ DMR2M17/Utils.h | 36 + DMR2M17/Version.h | 25 + DMR2M17/codec2/codebooks.cpp | 964 +++++++++++++++++ DMR2M17/codec2/codec2.cpp | 1745 ++++++++++++++++++++++++++++++ DMR2M17/codec2/codec2.h | 100 ++ DMR2M17/codec2/codec2_internal.h | 67 ++ DMR2M17/codec2/defines.h | 127 +++ DMR2M17/codec2/kiss_fft.cpp | 435 ++++++++ DMR2M17/codec2/kiss_fft.h | 35 + DMR2M17/codec2/lpc.cpp | 311 ++++++ DMR2M17/codec2/lpc.h | 47 + DMR2M17/codec2/nlp.cpp | 520 +++++++++ DMR2M17/codec2/nlp.h | 87 ++ DMR2M17/codec2/pack.cpp | 139 +++ DMR2M17/codec2/qbase.cpp | 247 +++++ DMR2M17/codec2/qbase.h | 39 + DMR2M17/codec2/quantise.cpp | 897 +++++++++++++++ DMR2M17/codec2/quantise.h | 68 ++ DMR2P25/DMR2P25 | Bin 0 -> 2793932 bytes DMR2P25/DMR2P25.cpp | 4 +- DSTAR2YSF/CRC.cpp | 254 +++++ DSTAR2YSF/CRC.h | 40 + DSTAR2YSF/Conf.cpp | 413 +++++++ DSTAR2YSF/Conf.h | 119 ++ DSTAR2YSF/DSTAR2YSF | Bin 0 -> 2386328 bytes DSTAR2YSF/DSTAR2YSF.cpp | 648 +++++++++++ DSTAR2YSF/DSTAR2YSF.h | 61 ++ DSTAR2YSF/DSTAR2YSF.ini | 43 + DSTAR2YSF/DSTARNetwork.cpp | 168 +++ DSTAR2YSF/DSTARNetwork.h | 49 + DSTAR2YSF/Golay24128.cpp | 1108 +++++++++++++++++++ DSTAR2YSF/Golay24128.h | 32 + DSTAR2YSF/Log.cpp | 136 +++ DSTAR2YSF/Log.h | 36 + DSTAR2YSF/Makefile | 21 + DSTAR2YSF/ModeConv.cpp | 524 +++++++++ DSTAR2YSF/ModeConv.h | 67 ++ DSTAR2YSF/RingBuffer.h | 154 +++ DSTAR2YSF/SerialController.cpp | 210 ++++ DSTAR2YSF/SerialController.h | 56 + DSTAR2YSF/StopWatch.cpp | 105 ++ DSTAR2YSF/StopWatch.h | 49 + DSTAR2YSF/Timer.cpp | 68 ++ DSTAR2YSF/Timer.h | 89 ++ DSTAR2YSF/UDPSocket.cpp | 262 +++++ DSTAR2YSF/UDPSocket.h | 58 + DSTAR2YSF/Utils.cpp | 146 +++ DSTAR2YSF/Utils.h | 36 + DSTAR2YSF/Version.h | 25 + DSTAR2YSF/YSFConvolution.cpp | 141 +++ DSTAR2YSF/YSFConvolution.h | 47 + DSTAR2YSF/YSFDefines.h | 49 + DSTAR2YSF/YSFFICH.cpp | 313 ++++++ DSTAR2YSF/YSFFICH.h | 65 ++ DSTAR2YSF/YSFNetwork.cpp | 180 +++ DSTAR2YSF/YSFNetwork.h | 64 ++ DSTAR2YSF/YSFPayload.cpp | 626 +++++++++++ DSTAR2YSF/YSFPayload.h | 57 + P252DMR/P252DMR | Bin 0 -> 2933908 bytes 125 files changed, 22159 insertions(+), 2 deletions(-) create mode 100644 DMR2M17/BPTC19696.cpp create mode 100644 DMR2M17/BPTC19696.h create mode 100644 DMR2M17/CRC.cpp create mode 100644 DMR2M17/CRC.h create mode 100644 DMR2M17/Conf.cpp create mode 100644 DMR2M17/Conf.h create mode 100644 DMR2M17/DMR2M17.cpp create mode 100644 DMR2M17/DMR2M17.h create mode 100644 DMR2M17/DMR2M17.ini create mode 100644 DMR2M17/DMRData.cpp create mode 100644 DMR2M17/DMRData.h create mode 100644 DMR2M17/DMRDefines.h create mode 100644 DMR2M17/DMREMB.cpp create mode 100644 DMR2M17/DMREMB.h create mode 100644 DMR2M17/DMREmbeddedData.cpp create mode 100644 DMR2M17/DMREmbeddedData.h create mode 100644 DMR2M17/DMRFullLC.cpp create mode 100644 DMR2M17/DMRFullLC.h create mode 100644 DMR2M17/DMRLC.cpp create mode 100644 DMR2M17/DMRLC.h create mode 100644 DMR2M17/DMRLookup.cpp create mode 100644 DMR2M17/DMRLookup.h create mode 100644 DMR2M17/DMRSlotType.cpp create mode 100644 DMR2M17/DMRSlotType.h create mode 100644 DMR2M17/Defines.h create mode 100644 DMR2M17/DelayBuffer.cpp create mode 100644 DMR2M17/DelayBuffer.h create mode 100644 DMR2M17/Golay2087.cpp create mode 100644 DMR2M17/Golay2087.h create mode 100644 DMR2M17/Golay24128.cpp create mode 100644 DMR2M17/Golay24128.h create mode 100644 DMR2M17/Hamming.cpp create mode 100644 DMR2M17/Hamming.h create mode 100644 DMR2M17/LICENSE create mode 100644 DMR2M17/Log.cpp create mode 100644 DMR2M17/Log.h create mode 100644 DMR2M17/M17Network.cpp create mode 100644 DMR2M17/M17Network.h create mode 100644 DMR2M17/MBEVocoder.cpp create mode 100644 DMR2M17/MBEVocoder.h create mode 100644 DMR2M17/MMDVMNetwork.cpp create mode 100644 DMR2M17/MMDVMNetwork.h create mode 100644 DMR2M17/Makefile create mode 100644 DMR2M17/ModeConv.cpp create mode 100644 DMR2M17/ModeConv.h create mode 100644 DMR2M17/Mutex.cpp create mode 100644 DMR2M17/Mutex.h create mode 100644 DMR2M17/QR1676.cpp create mode 100644 DMR2M17/QR1676.h create mode 100644 DMR2M17/README.md create mode 100644 DMR2M17/RS129.cpp create mode 100644 DMR2M17/RS129.h create mode 100644 DMR2M17/RingBuffer.h create mode 100644 DMR2M17/SHA256.cpp create mode 100644 DMR2M17/SHA256.h create mode 100644 DMR2M17/StopWatch.cpp create mode 100644 DMR2M17/StopWatch.h create mode 100644 DMR2M17/Sync.cpp create mode 100644 DMR2M17/Sync.h create mode 100644 DMR2M17/Thread.cpp create mode 100644 DMR2M17/Thread.h create mode 100644 DMR2M17/Timer.cpp create mode 100644 DMR2M17/Timer.h create mode 100644 DMR2M17/UDPSocket.cpp create mode 100644 DMR2M17/UDPSocket.h create mode 100644 DMR2M17/Utils.cpp create mode 100644 DMR2M17/Utils.h create mode 100644 DMR2M17/Version.h create mode 100644 DMR2M17/codec2/codebooks.cpp create mode 100644 DMR2M17/codec2/codec2.cpp create mode 100644 DMR2M17/codec2/codec2.h create mode 100644 DMR2M17/codec2/codec2_internal.h create mode 100644 DMR2M17/codec2/defines.h create mode 100644 DMR2M17/codec2/kiss_fft.cpp create mode 100644 DMR2M17/codec2/kiss_fft.h create mode 100644 DMR2M17/codec2/lpc.cpp create mode 100644 DMR2M17/codec2/lpc.h create mode 100644 DMR2M17/codec2/nlp.cpp create mode 100644 DMR2M17/codec2/nlp.h create mode 100644 DMR2M17/codec2/pack.cpp create mode 100644 DMR2M17/codec2/qbase.cpp create mode 100644 DMR2M17/codec2/qbase.h create mode 100644 DMR2M17/codec2/quantise.cpp create mode 100644 DMR2M17/codec2/quantise.h create mode 100755 DMR2P25/DMR2P25 create mode 100644 DSTAR2YSF/CRC.cpp create mode 100644 DSTAR2YSF/CRC.h create mode 100644 DSTAR2YSF/Conf.cpp create mode 100644 DSTAR2YSF/Conf.h create mode 100755 DSTAR2YSF/DSTAR2YSF create mode 100644 DSTAR2YSF/DSTAR2YSF.cpp create mode 100644 DSTAR2YSF/DSTAR2YSF.h create mode 100644 DSTAR2YSF/DSTAR2YSF.ini create mode 100644 DSTAR2YSF/DSTARNetwork.cpp create mode 100644 DSTAR2YSF/DSTARNetwork.h create mode 100644 DSTAR2YSF/Golay24128.cpp create mode 100644 DSTAR2YSF/Golay24128.h create mode 100644 DSTAR2YSF/Log.cpp create mode 100644 DSTAR2YSF/Log.h create mode 100644 DSTAR2YSF/Makefile create mode 100644 DSTAR2YSF/ModeConv.cpp create mode 100644 DSTAR2YSF/ModeConv.h create mode 100644 DSTAR2YSF/RingBuffer.h create mode 100644 DSTAR2YSF/SerialController.cpp create mode 100644 DSTAR2YSF/SerialController.h create mode 100644 DSTAR2YSF/StopWatch.cpp create mode 100644 DSTAR2YSF/StopWatch.h create mode 100644 DSTAR2YSF/Timer.cpp create mode 100644 DSTAR2YSF/Timer.h create mode 100644 DSTAR2YSF/UDPSocket.cpp create mode 100644 DSTAR2YSF/UDPSocket.h create mode 100644 DSTAR2YSF/Utils.cpp create mode 100644 DSTAR2YSF/Utils.h create mode 100644 DSTAR2YSF/Version.h create mode 100644 DSTAR2YSF/YSFConvolution.cpp create mode 100644 DSTAR2YSF/YSFConvolution.h create mode 100644 DSTAR2YSF/YSFDefines.h create mode 100644 DSTAR2YSF/YSFFICH.cpp create mode 100644 DSTAR2YSF/YSFFICH.h create mode 100644 DSTAR2YSF/YSFNetwork.cpp create mode 100644 DSTAR2YSF/YSFNetwork.h create mode 100644 DSTAR2YSF/YSFPayload.cpp create mode 100644 DSTAR2YSF/YSFPayload.h create mode 100755 P252DMR/P252DMR diff --git a/DMR2M17/BPTC19696.cpp b/DMR2M17/BPTC19696.cpp new file mode 100644 index 0000000..289005a --- /dev/null +++ b/DMR2M17/BPTC19696.cpp @@ -0,0 +1,347 @@ +/* + * 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_2(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 9 rows containing data + for (unsigned int r = 0U; r < 9U; r++) { + unsigned int pos = (r * 15U) + 1U; + CHamming::encode15113_2(m_deInterData + pos); + } + + // 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; + } + } +} + +// 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[20U] = (data[20U] & 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/DMR2M17/BPTC19696.h b/DMR2M17/BPTC19696.h new file mode 100644 index 0000000..0a40a78 --- /dev/null +++ b/DMR2M17/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/DMR2M17/CRC.cpp b/DMR2M17/CRC.cpp new file mode 100644 index 0000000..e19f429 --- /dev/null +++ b/DMR2M17/CRC.cpp @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 "Log.h" + +#include +#include +#include +#include + +const uint8_t CRC8_TABLE[] = { + 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, + 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, + 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, 0xE0, 0xE7, 0xEE, 0xE9, + 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, + 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, + 0xB4, 0xB3, 0xBA, 0xBD, 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, + 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, 0xB7, 0xB0, 0xB9, 0xBE, + 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, + 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, + 0x03, 0x04, 0x0D, 0x0A, 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, + 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, 0x89, 0x8E, 0x87, 0x80, + 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, + 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, + 0xDD, 0xDA, 0xD3, 0xD4, 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, + 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, 0x19, 0x1E, 0x17, 0x10, + 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, + 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, + 0x6A, 0x6D, 0x64, 0x63, 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, + 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13, 0xAE, 0xA9, 0xA0, 0xA7, + 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, + 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, + 0xFA, 0xFD, 0xF4, 0xF3, 0x01 }; + +const uint16_t CCITT16_TABLE1[] = { + 0x0000U, 0x1189U, 0x2312U, 0x329bU, 0x4624U, 0x57adU, 0x6536U, 0x74bfU, + 0x8c48U, 0x9dc1U, 0xaf5aU, 0xbed3U, 0xca6cU, 0xdbe5U, 0xe97eU, 0xf8f7U, + 0x1081U, 0x0108U, 0x3393U, 0x221aU, 0x56a5U, 0x472cU, 0x75b7U, 0x643eU, + 0x9cc9U, 0x8d40U, 0xbfdbU, 0xae52U, 0xdaedU, 0xcb64U, 0xf9ffU, 0xe876U, + 0x2102U, 0x308bU, 0x0210U, 0x1399U, 0x6726U, 0x76afU, 0x4434U, 0x55bdU, + 0xad4aU, 0xbcc3U, 0x8e58U, 0x9fd1U, 0xeb6eU, 0xfae7U, 0xc87cU, 0xd9f5U, + 0x3183U, 0x200aU, 0x1291U, 0x0318U, 0x77a7U, 0x662eU, 0x54b5U, 0x453cU, + 0xbdcbU, 0xac42U, 0x9ed9U, 0x8f50U, 0xfbefU, 0xea66U, 0xd8fdU, 0xc974U, + 0x4204U, 0x538dU, 0x6116U, 0x709fU, 0x0420U, 0x15a9U, 0x2732U, 0x36bbU, + 0xce4cU, 0xdfc5U, 0xed5eU, 0xfcd7U, 0x8868U, 0x99e1U, 0xab7aU, 0xbaf3U, + 0x5285U, 0x430cU, 0x7197U, 0x601eU, 0x14a1U, 0x0528U, 0x37b3U, 0x263aU, + 0xdecdU, 0xcf44U, 0xfddfU, 0xec56U, 0x98e9U, 0x8960U, 0xbbfbU, 0xaa72U, + 0x6306U, 0x728fU, 0x4014U, 0x519dU, 0x2522U, 0x34abU, 0x0630U, 0x17b9U, + 0xef4eU, 0xfec7U, 0xcc5cU, 0xddd5U, 0xa96aU, 0xb8e3U, 0x8a78U, 0x9bf1U, + 0x7387U, 0x620eU, 0x5095U, 0x411cU, 0x35a3U, 0x242aU, 0x16b1U, 0x0738U, + 0xffcfU, 0xee46U, 0xdcddU, 0xcd54U, 0xb9ebU, 0xa862U, 0x9af9U, 0x8b70U, + 0x8408U, 0x9581U, 0xa71aU, 0xb693U, 0xc22cU, 0xd3a5U, 0xe13eU, 0xf0b7U, + 0x0840U, 0x19c9U, 0x2b52U, 0x3adbU, 0x4e64U, 0x5fedU, 0x6d76U, 0x7cffU, + 0x9489U, 0x8500U, 0xb79bU, 0xa612U, 0xd2adU, 0xc324U, 0xf1bfU, 0xe036U, + 0x18c1U, 0x0948U, 0x3bd3U, 0x2a5aU, 0x5ee5U, 0x4f6cU, 0x7df7U, 0x6c7eU, + 0xa50aU, 0xb483U, 0x8618U, 0x9791U, 0xe32eU, 0xf2a7U, 0xc03cU, 0xd1b5U, + 0x2942U, 0x38cbU, 0x0a50U, 0x1bd9U, 0x6f66U, 0x7eefU, 0x4c74U, 0x5dfdU, + 0xb58bU, 0xa402U, 0x9699U, 0x8710U, 0xf3afU, 0xe226U, 0xd0bdU, 0xc134U, + 0x39c3U, 0x284aU, 0x1ad1U, 0x0b58U, 0x7fe7U, 0x6e6eU, 0x5cf5U, 0x4d7cU, + 0xc60cU, 0xd785U, 0xe51eU, 0xf497U, 0x8028U, 0x91a1U, 0xa33aU, 0xb2b3U, + 0x4a44U, 0x5bcdU, 0x6956U, 0x78dfU, 0x0c60U, 0x1de9U, 0x2f72U, 0x3efbU, + 0xd68dU, 0xc704U, 0xf59fU, 0xe416U, 0x90a9U, 0x8120U, 0xb3bbU, 0xa232U, + 0x5ac5U, 0x4b4cU, 0x79d7U, 0x685eU, 0x1ce1U, 0x0d68U, 0x3ff3U, 0x2e7aU, + 0xe70eU, 0xf687U, 0xc41cU, 0xd595U, 0xa12aU, 0xb0a3U, 0x8238U, 0x93b1U, + 0x6b46U, 0x7acfU, 0x4854U, 0x59ddU, 0x2d62U, 0x3cebU, 0x0e70U, 0x1ff9U, + 0xf78fU, 0xe606U, 0xd49dU, 0xc514U, 0xb1abU, 0xa022U, 0x92b9U, 0x8330U, + 0x7bc7U, 0x6a4eU, 0x58d5U, 0x495cU, 0x3de3U, 0x2c6aU, 0x1ef1U, 0x0f78U }; + +const uint16_t CCITT16_TABLE2[] = { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, + 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, + 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, + 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, + 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, + 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, + 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, + 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, + 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, + 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, + 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, + 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, + 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, + 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, + 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, + 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, + 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, + 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, + 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, + 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, + 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, + 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, + 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, + 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, + 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 }; + + +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; +} + +void CCRC::addCCITT162(unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0U; + + for (unsigned i = 0U; i < (length - 2U); i++) + crc16 = (uint16_t(crc8[0U]) << 8) ^ CCITT16_TABLE2[crc8[1U] ^ in[i]]; + + crc16 = ~crc16; + + in[length - 1U] = crc8[0U]; + in[length - 2U] = crc8[1U]; +} + +bool CCRC::checkCCITT162(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0U; + + for (unsigned i = 0U; i < (length - 2U); i++) + crc16 = (uint16_t(crc8[0U]) << 8) ^ CCITT16_TABLE2[crc8[1U] ^ in[i]]; + + crc16 = ~crc16; + + return crc8[0U] == in[length - 1U] && crc8[1U] == in[length - 2U]; +} + +void CCRC::addCCITT161(unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0xFFFFU; + + for (unsigned int i = 0U; i < (length - 2U); i++) + crc16 = uint16_t(crc8[1U]) ^ CCITT16_TABLE1[crc8[0U] ^ in[i]]; + + crc16 = ~crc16; + + in[length - 2U] = crc8[0U]; + in[length - 1U] = crc8[1U]; +} + +bool CCRC::checkCCITT161(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0xFFFFU; + + for (unsigned int i = 0U; i < (length - 2U); i++) + crc16 = uint16_t(crc8[1U]) ^ CCITT16_TABLE1[crc8[0U] ^ in[i]]; + + crc16 = ~crc16; + + return crc8[0U] == in[length - 2U] && crc8[1U] == in[length - 1U]; +} + +unsigned char CCRC::crc8(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + + uint8_t crc = 0U; + + for (unsigned int i = 0U; i < length; i++) + crc = CRC8_TABLE[crc ^ in[i]]; + + return crc; +} + +unsigned char CCRC::addCRC(const unsigned char* in, unsigned int length) +{ + assert(in != NULL); + + unsigned char crc = 0U; + + for (unsigned int i = 0U; i < length; i++) + crc += in[i]; + + return crc; +} + diff --git a/DMR2M17/CRC.h b/DMR2M17/CRC.h new file mode 100644 index 0000000..d529271 --- /dev/null +++ b/DMR2M17/CRC.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 void addCCITT161(unsigned char* in, unsigned int length); + static void addCCITT162(unsigned char* in, unsigned int length); + + static bool checkCCITT161(const unsigned char* in, unsigned int length); + static bool checkCCITT162(const unsigned char* in, unsigned int length); + + static unsigned char crc8(const unsigned char* in, unsigned int length); + + static unsigned char addCRC(const unsigned char* in, unsigned int length); +}; + +#endif diff --git a/DMR2M17/Conf.cpp b/DMR2M17/Conf.cpp new file mode 100644 index 0000000..730723c --- /dev/null +++ b/DMR2M17/Conf.cpp @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * Copyright (C) 2020 by Doug McLain AD8DP + * + * 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 +#include + +const int BUFFER_SIZE = 500; + +enum SECTION { + SECTION_NONE, + SECTION_M17_NETWORK, + SECTION_DMR_NETWORK, + SECTION_DMRID_LOOKUP, + SECTION_LOG +}; + +CConf::CConf(const std::string& file) : +m_file(file), +m_callsign(), +m_daemon(false), +m_dmrId(0U), +m_dmrRptAddress(), +m_dmrRptPort(0U), +m_dmrLocalAddress(), +m_dmrLocalPort(0U), +m_dmrDebug(false), +m_m17DstId(0U), +m_m17DstName(), +m_m17DstAddress(), +m_m17DstPort(0U), +m_m17LocalAddress(), +m_m17LocalPort(0U), +m_m17GainAdjDb(), +m_m17NetworkDebug(false), +m_dmrIdLookupFile(), +m_dmrIdLookupTime(0U), +m_logDisplayLevel(0U), +m_logFileLevel(0U), +m_logFilePath(), +m_logFileRoot() +{ +} + +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, "[M17 Network]", 13U) == 0) + section = SECTION_M17_NETWORK; + else if (::strncmp(buffer, "[DMR Network]", 13U) == 0) + section = SECTION_DMR_NETWORK; + else if (::strncmp(buffer, "[DMR Id Lookup]", 15U) == 0) + section = SECTION_DMRID_LOOKUP; + else if (::strncmp(buffer, "[Log]", 5U) == 0) + section = SECTION_LOG; + else + section = SECTION_NONE; + + continue; + } + + char* key = ::strtok(buffer, " \t=\r\n"); + if (key == NULL) + continue; + + char* value = ::strtok(NULL, "\r\n"); + if (value == NULL) + continue; + + // Remove quotes from the value + size_t len = ::strlen(value); + if (len > 1U && *value == '"' && value[len - 1U] == '"') { + value[len - 1U] = '\0'; + value++; + } + ::fprintf(stderr, "CConf key:val:section == %s:%s:%d\n", key, value, section); + if (section == SECTION_M17_NETWORK) { + if (::strcmp(key, "Callsign") == 0) + m_callsign = value; + else if (::strcmp(key, "StartupDstId") == 0) + m_m17DstId = (unsigned int)::atoi(value); + else if (::strcmp(key, "LocalAddress") == 0) + m_m17LocalAddress = value; + else if (::strcmp(key, "LocalPort") == 0) + m_m17LocalPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "DstName") == 0) + m_m17DstName = value; + else if (::strcmp(key, "DstAddress") == 0) + m_m17DstAddress = value; + else if (::strcmp(key, "DstPort") == 0) + m_m17DstPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "GainAdjustdB") == 0) + m_m17GainAdjDb = value; + else if (::strcmp(key, "Debug") == 0) + m_m17NetworkDebug = ::atoi(value) == 1; + } else if (section == SECTION_DMR_NETWORK) { + if (::strcmp(key, "Id") == 0) + m_dmrId = (unsigned int)::atoi(value); + else if (::strcmp(key, "RptAddress") == 0) + m_dmrRptAddress = value; + else if (::strcmp(key, "RptPort") == 0) + m_dmrRptPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "LocalAddress") == 0) + m_dmrLocalAddress = value; + else if (::strcmp(key, "LocalPort") == 0) + m_dmrLocalPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "Debug") == 0) + m_dmrDebug = ::atoi(value) == 1; + } else if (section == SECTION_DMRID_LOOKUP) { + if (::strcmp(key, "File") == 0) + m_dmrIdLookupFile = value; + else if (::strcmp(key, "Time") == 0) + m_dmrIdLookupTime = (unsigned int)::atoi(value); + } else if (section == SECTION_LOG) { + if (::strcmp(key, "FilePath") == 0) + m_logFilePath = value; + else if (::strcmp(key, "FileRoot") == 0) + m_logFileRoot = value; + else if (::strcmp(key, "FileLevel") == 0) + m_logFileLevel = (unsigned int)::atoi(value); + else if (::strcmp(key, "DisplayLevel") == 0) + m_logDisplayLevel = (unsigned int)::atoi(value); + } + } + + ::fclose(fp); + + return true; +} + +std::string CConf::getCallsign() const +{ + return m_callsign; +} + +std::string CConf::getM17DstName() const +{ + return m_m17DstName; +} + +std::string CConf::getM17DstAddress() const +{ + return m_m17DstAddress; +} + +unsigned int CConf::getM17DstPort() const +{ + return m_m17DstPort; +} + +std::string CConf::getM17LocalAddress() const +{ + return m_m17LocalAddress; +} + +unsigned int CConf::getM17LocalPort() const +{ + return m_m17LocalPort; +} + +std::string CConf::getM17GainAdjDb() const +{ + return m_m17GainAdjDb; +} + +bool CConf::getM17NetworkDebug() const +{ + return m_m17NetworkDebug; +} + +bool CConf::getDaemon() const +{ + return m_daemon; +} + +unsigned int CConf::getDMRId() const +{ + return m_dmrId; +} + +std::string CConf::getDMRRptAddress() const +{ + return m_dmrRptAddress; +} + +unsigned int CConf::getDMRRptPort() const +{ + return m_dmrRptPort; +} + +std::string CConf::getDMRLocalAddress() const +{ + return m_dmrLocalAddress; +} + +unsigned int CConf::getDMRLocalPort() const +{ + return m_dmrLocalPort; +} + +bool CConf::getDMRDebug() const +{ + return m_dmrDebug; +} + +std::string CConf::getDMRIdLookupFile() const +{ + return m_dmrIdLookupFile; +} + +unsigned int CConf::getDMRIdLookupTime() const +{ + return m_dmrIdLookupTime; +} + +unsigned int CConf::getLogDisplayLevel() const +{ + return m_logDisplayLevel; +} + +unsigned int CConf::getLogFileLevel() const +{ + return m_logFileLevel; +} + +std::string CConf::getLogFilePath() const +{ + return m_logFilePath; +} + +std::string CConf::getLogFileRoot() const +{ + return m_logFileRoot; +} diff --git a/DMR2M17/Conf.h b/DMR2M17/Conf.h new file mode 100644 index 0000000..d68ae18 --- /dev/null +++ b/DMR2M17/Conf.h @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU +* Copyright (C) 2020 by Doug McLain AD8DP + * + * 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 +#include + +class CConf +{ +public: + CConf(const std::string& file); + ~CConf(); + + bool read(); + + // The M17 Network section + std::string getCallsign() const; + bool getDaemon() const; + unsigned int getM17DstId() const; + std::string getM17DstName() const; + std::string getM17DstAddress() const; + unsigned int getM17DstPort() const; + std::string getM17LocalAddress() const; + unsigned int getM17LocalPort() const; + std::string getM17GainAdjDb() const; + bool getM17NetworkDebug() const; + + // The DMR Network section + unsigned int getDMRId() const; + std::string getDMRRptAddress() const; + unsigned int getDMRRptPort() const; + std::string getDMRLocalAddress() const; + unsigned int getDMRLocalPort() const; + bool getDMRDebug() const; + + // The DMR Id section + std::string getDMRIdLookupFile() const; + unsigned int getDMRIdLookupTime() const; + + // The Log section + unsigned int getLogDisplayLevel() const; + unsigned int getLogFileLevel() const; + std::string getLogFilePath() const; + std::string getLogFileRoot() const; + +private: + std::string m_file; + std::string m_callsign; + bool m_daemon; + + unsigned int m_dmrId; + std::string m_dmrRptAddress; + unsigned int m_dmrRptPort; + std::string m_dmrLocalAddress; + unsigned int m_dmrLocalPort; + bool m_dmrDebug; + + unsigned int m_m17DstId; + std::string m_m17DstName; + std::string m_m17DstAddress; + unsigned int m_m17DstPort; + std::string m_m17LocalAddress; + unsigned int m_m17LocalPort; + std::string m_m17GainAdjDb; + bool m_m17NetworkDebug; + + std::string m_dmrIdLookupFile; + unsigned int m_dmrIdLookupTime; + + unsigned int m_logDisplayLevel; + unsigned int m_logFileLevel; + std::string m_logFilePath; + std::string m_logFileRoot; + +}; + +#endif diff --git a/DMR2M17/DMR2M17.cpp b/DMR2M17/DMR2M17.cpp new file mode 100644 index 0000000..ccd4f84 --- /dev/null +++ b/DMR2M17/DMR2M17.cpp @@ -0,0 +1,694 @@ +/* +* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* Copyright (C) 2020 by Doug McLain AD8DP +* +* 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 "DMR2M17.h" +#include +#include +#include +#include +#include + +#define DMR_FRAME_PER 55U +#define M17_FRAME_PER 35U + +const char* DEFAULT_INI_FILE = "/etc/DMR2M17.ini"; + +const char* HEADER1 = "This software is for use on amateur radio networks only,"; +const char* HEADER2 = "it is to be used for educational purposes only. Its use on"; +const char* HEADER3 = "commercial networks is strictly prohibited."; +const char* HEADER4 = "Copyright(C) 2018 by CA6JAU, G4KLX and others"; + +#define M17CHARACTERS " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-/." + +#include +#include +#include +#include +#include +#include +#include + +static bool m_killed = false; + +void sig_handler(int signo) +{ + if (signo == SIGTERM) { + m_killed = true; + ::fprintf(stdout, "Received SIGTERM\n"); + } +} + +void encode_callsign(uint8_t *callsign) +{ + const std::string m17_alphabet(M17CHARACTERS); + char cs[10]; + memset(cs, 0, sizeof(cs)); + memcpy(cs, callsign, strlen((char *)callsign)); + uint64_t encoded = 0; + for(int i = std::strlen((char *)callsign)-1; i >= 0; i--) { + auto pos = m17_alphabet.find(cs[i]); + if (pos == std::string::npos) { + pos = 0; + } + encoded *= 40; + encoded += pos; + } + for (int i=0; i<6; i++) { + callsign[i] = (encoded >> (8*(5-i)) & 0xFFU); + } +} + +void decode_callsign(uint8_t *callsign) +{ + const std::string m17_alphabet(M17CHARACTERS); + uint8_t code[6]; + uint64_t coded = callsign[0]; + for (int i=1; i<6; i++) + coded = (coded << 8) | callsign[i]; + if (coded > 0xee6b27ffffffu) { + //std::cerr << "Callsign code is too large, 0x" << std::hex << coded << std::endl; + return; + } + memcpy(code, callsign, 6); + memset(callsign, 0, 10); + int i = 0; + while (coded) { + callsign[i++] = m17_alphabet[coded % 40]; + coded /= 40; + } +} + +int main(int argc, char** argv) +{ + const char* iniFile = DEFAULT_INI_FILE; + if (argc > 1) { + for (int currentArg = 1; currentArg < argc; ++currentArg) { + std::string arg = argv[currentArg]; + if ((arg == "-v") || (arg == "--version")) { + ::fprintf(stdout, "DMR2M17 version %s\n", VERSION); + return 0; + } else if (arg.substr(0, 1) == "-") { + ::fprintf(stderr, "Usage: DMR2M17 [-v|--version] [filename]\n"); + return 1; + } else { + iniFile = argv[currentArg]; + } + } + } + + // Capture SIGTERM to finish gracelessly + if (signal(SIGTERM, sig_handler) == SIG_ERR) + ::fprintf(stdout, "Can't catch SIGTERM\n"); + + CDMR2M17* gateway = new CDMR2M17(std::string(iniFile)); + + int ret = gateway->run(); + + delete gateway; + + return ret; +} + +CDMR2M17::CDMR2M17(const std::string& configFile) : +m_callsign(), +m_m17Ref(), +m_conf(configFile), +m_dmrNetwork(NULL), +m_m17Network(NULL), +m_dmrlookup(NULL), +m_conv(), +m_colorcode(1U), +m_dstid(1U), +m_dmrSrc(1U), +m_dmrDst(1U), +m_dmrLastDT(0U), +m_dmrFrame(NULL), +m_dmrFrames(0U), +m_m17Src(), +m_m17Dst(), +m_m17Frame(NULL), +m_m17Frames(0U), +m_EmbeddedLC(), +m_dmrflco(FLCO_GROUP), +m_dmrinfo(false), +m_config(NULL), +m_configLen(0U) +{ + m_m17Frame = new unsigned char[100U]; + m_dmrFrame = new unsigned char[50U]; + m_config = new unsigned char[400U]; + + ::memset(m_m17Frame, 0U, 100U); + ::memset(m_dmrFrame, 0U, 50U); +} + +CDMR2M17::~CDMR2M17() +{ + delete[] m_m17Frame; + delete[] m_dmrFrame; + delete[] m_config; +} + +int CDMR2M17::run() +{ + bool ret = m_conf.read(); + if (!ret) { + ::fprintf(stderr, "DMR2NXDN: cannot read the .ini file\n"); + return 1; + } + + //setlocale(LC_ALL, "C"); + + unsigned int logDisplayLevel = m_conf.getLogDisplayLevel(); + + if(m_conf.getDaemon()) + logDisplayLevel = 0U; + + bool m_daemon = m_conf.getDaemon(); + if (m_daemon) { + // Create new process + pid_t pid = ::fork(); + if (pid == -1) { + ::fprintf(stderr, "Couldn't fork() , exiting\n"); + return -1; + } else if (pid != 0) + exit(EXIT_SUCCESS); + + // Create new session and process group + if (::setsid() == -1) { + ::fprintf(stderr, "Couldn't setsid(), exiting\n"); + return -1; + } + + // Set the working directory to the root directory + if (::chdir("/") == -1) { + ::fprintf(stderr, "Couldn't cd /, exiting\n"); + return -1; + } + + // If we are currently root... + if (getuid() == 0) { + struct passwd* user = ::getpwnam("mmdvm"); + if (user == NULL) { + ::fprintf(stderr, "Could not get the mmdvm user, exiting\n"); + return -1; + } + + uid_t mmdvm_uid = user->pw_uid; + gid_t mmdvm_gid = user->pw_gid; + + // Set user and group ID's to mmdvm:mmdvm + if (setgid(mmdvm_gid) != 0) { + ::fprintf(stderr, "Could not set mmdvm GID, exiting\n"); + return -1; + } + + if (setuid(mmdvm_uid) != 0) { + ::fprintf(stderr, "Could not set mmdvm UID, exiting\n"); + return -1; + } + + // Double check it worked (AKA Paranoia) + if (setuid(0) != -1) { + ::fprintf(stderr, "It's possible to regain root - something is wrong!, exiting\n"); + return -1; + } + } + } + + ret = ::LogInitialise(m_conf.getLogFilePath(), m_conf.getLogFileRoot(), m_conf.getLogFileLevel(), logDisplayLevel); + if (!ret) { + ::fprintf(stderr, "DMR2M17: unable to open the log file\n"); + return 1; + } + + if (m_daemon) { + ::close(STDIN_FILENO); + ::close(STDOUT_FILENO); + ::close(STDERR_FILENO); + } + + LogInfo(HEADER1); + LogInfo(HEADER2); + LogInfo(HEADER3); + LogInfo(HEADER4); + + m_callsign = m_conf.getCallsign(); + m_m17Ref = m_conf.getM17DstName(); + + std::string m17_dstAddress = m_conf.getM17DstAddress(); + unsigned int m17_dstPort = m_conf.getM17DstPort(); + std::string m17_localAddress = m_conf.getM17LocalAddress(); + unsigned int m17_localPort = m_conf.getM17LocalPort(); + bool m17_debug = m_conf.getM17NetworkDebug(); + + m_conv.setM17GainAdjDb(m_conf.getM17GainAdjDb()); + + uint16_t streamid = 0; + unsigned char m17_src[10]; + unsigned char m17_dst[10]; + + memcpy(m17_src, m_callsign.c_str(), 9); + m17_src[9] = 0x00; + encode_callsign(m17_src); + + m_m17Network = new CM17Network(m17_localAddress, m17_localPort, m17_dstAddress, m17_dstPort, m17_src, m17_debug); + + ret = m_m17Network->open(); + if (!ret) { + ::LogError("Cannot open the M17 network port"); + ::LogFinalise(); + return 1; + } + + ret = createMMDVM(); + if (!ret) + return 1; + + LogMessage("Waiting for MMDVM to connect....."); + + while (!m_killed) { + m_configLen = m_dmrNetwork->getConfig(m_config); + if (m_configLen > 0U && m_dmrNetwork->getId() > 1000U) + break; + + m_dmrNetwork->clock(10U); + + CThread::sleep(10U); + } + + if (m_killed) { + m_dmrNetwork->close(); + delete m_dmrNetwork; + return 0; + } + + LogMessage("MMDVM has connected"); + + std::string lookupFile = m_conf.getDMRIdLookupFile(); + unsigned int reloadTime = m_conf.getDMRIdLookupTime(); + + m_dmrlookup = new CDMRLookup(lookupFile, reloadTime); + m_dmrlookup->read(); + + m_dmrflco = FLCO_GROUP; + + CTimer networkWatchdog(100U, 0U, 1500U); + CTimer pollTimer(1000U, 8U); + CStopWatch stopWatch; + CStopWatch m17Watch; + CStopWatch dmrWatch; + + pollTimer.start(); + stopWatch.start(); + m17Watch.start(); + dmrWatch.start(); + + unsigned short m17_cnt = 0; + unsigned char dmr_cnt = 0; + + m_m17Network->writeLink(); + + LogMessage("Starting DMR2M17-%s", VERSION); + + for (; m_killed == 0;) { + unsigned char buffer[2000U]; + memset(buffer, 0, sizeof(buffer)); + + CDMRData tx_dmrdata; + unsigned int ms = stopWatch.elapsed(); + + if (m17Watch.elapsed() > M17_FRAME_PER) { + unsigned int m17FrameType = m_conv.getM17(m_m17Frame); + + if(m17FrameType == TAG_HEADER) { + m17_cnt = 0U; + m17Watch.start(); + + streamid = static_cast((::rand() & 0xFFFF)); + memcpy(m17_dst, m_m17Ref.c_str(), m_m17Ref.size()); + m17_dst[9] = 0x00; + encode_callsign(m17_dst); + + memcpy(buffer, "M17 ", 4); + memcpy(buffer+4, &streamid, 2); + memcpy(buffer+6, m17_dst, 6); + memcpy(buffer+12, m17_src, 6); + buffer[19] = 0x05; + memcpy(buffer+36, m_m17Frame, 16); + m_m17Network->writeData(buffer, 54U); + } + else if(m17FrameType == TAG_EOT) { + m17_cnt |= 0x8000; + memcpy(buffer, "M17 ", 4); + memcpy(buffer+4, &streamid, 2); + memcpy(buffer+6, m17_dst, 6); + memcpy(buffer+12, m17_src, 6); + buffer[19] = 0x05; + buffer[34] = m17_cnt >> 8; + buffer[35] = m17_cnt & 0xff; + memcpy(buffer+36, m_m17Frame, 16); + m_m17Network->writeData(buffer, 54U); + m17Watch.start(); + } + else if(m17FrameType == TAG_DATA) { + //CUtils::dump(1U, "P25 Data", m_p25Frame, 11U); + m17_cnt++; + memcpy(buffer, "M17 ", 4); + memcpy(buffer+4, &streamid, 2); + memcpy(buffer+6, m17_dst, 6); + memcpy(buffer+12, m17_src, 6); + buffer[19] = 0x05; + buffer[34] = m17_cnt >> 8; + buffer[35] = m17_cnt & 0xff; + memcpy(buffer+36, m_m17Frame, 16); + m_m17Network->writeData(buffer, 54U); + m17Watch.start(); + } + } + + while (m_m17Network->readData(m_m17Frame, 54U) > 0U) { + //CUtils::dump(1U, "P25 Data", m_p25Frame, 22U); + if (!memcmp(m_m17Frame, "M17 ", 4)) { + if (m_m17Frame[34] == 0 && m_m17Frame[35] == 0) { + m_m17Frames = 0; + m_conv.putM17Header(); + } + else if (m_m17Frame[34U] & 0x80U) { + LogMessage("M17 received end of voice transmission, %.1f seconds", float(m_m17Frames) / 25.0F); + m_conv.putM17EOT(); + } + else{ + m_conv.putM17(m_m17Frame); + } + uint8_t cs[10]; + memcpy(cs, m_m17Frame+12, 6); + decode_callsign(cs); + std::string css((char *)cs); + css = css.substr(0, css.find(' ')); + + int dmrid = m_dmrlookup->findID(css); + if(dmrid){ + m_dmrSrc = dmrid; + } + m_m17Frames++; + } + } + + if (dmrWatch.elapsed() > DMR_FRAME_PER) { + unsigned int dmrFrameType = m_conv.getDMR(m_dmrFrame); + if(dmrFrameType == TAG_HEADER) { + CDMRData rx_dmrdata; + dmr_cnt = 0U; + + rx_dmrdata.setSlotNo(2U); + rx_dmrdata.setSrcId(m_dmrSrc); + rx_dmrdata.setDstId(m_dmrDst); + rx_dmrdata.setFLCO(m_dmrflco); + rx_dmrdata.setN(0U); + rx_dmrdata.setSeqNo(0U); + rx_dmrdata.setBER(0U); + rx_dmrdata.setRSSI(0U); + rx_dmrdata.setDataType(DT_VOICE_LC_HEADER); + + // Add sync + CSync::addDMRDataSync(m_dmrFrame, 0); + + // Add SlotType + CDMRSlotType slotType; + slotType.setColorCode(m_colorcode); + slotType.setDataType(DT_VOICE_LC_HEADER); + slotType.getData(m_dmrFrame); + + // Full LC + CDMRLC dmrLC = CDMRLC(m_dmrflco, m_dmrSrc, m_dmrDst); + CDMRFullLC fullLC; + fullLC.encode(dmrLC, m_dmrFrame, DT_VOICE_LC_HEADER); + m_EmbeddedLC.setLC(dmrLC); + + rx_dmrdata.setData(m_dmrFrame); + //CUtils::dump(1U, "DMR data:", m_dmrFrame, 33U); + + for (unsigned int i = 0U; i < 3U; i++) { + rx_dmrdata.setSeqNo(dmr_cnt); + m_dmrNetwork->write(rx_dmrdata); + dmr_cnt++; + } + + dmrWatch.start(); + } + else if(dmrFrameType == TAG_EOT) { + CDMRData rx_dmrdata; + unsigned int n_dmr = (dmr_cnt - 3U) % 6U; + unsigned int fill = (6U - n_dmr); + + if (n_dmr) { + for (unsigned int i = 0U; i < fill; i++) { + + CDMREMB emb; + CDMRData rx_dmrdata; + + rx_dmrdata.setSlotNo(2U); + rx_dmrdata.setSrcId(m_dmrSrc); + rx_dmrdata.setDstId(m_dmrDst); + rx_dmrdata.setFLCO(m_dmrflco); + rx_dmrdata.setN(n_dmr); + rx_dmrdata.setSeqNo(dmr_cnt); + rx_dmrdata.setBER(0U); + rx_dmrdata.setRSSI(0U); + rx_dmrdata.setDataType(DT_VOICE); + + ::memcpy(m_dmrFrame, DMR_SILENCE_DATA, DMR_FRAME_LENGTH_BYTES); + + // Generate the Embedded LC + unsigned char lcss = m_EmbeddedLC.getData(m_dmrFrame, n_dmr); + + // Generate the EMB + emb.setColorCode(m_colorcode); + emb.setLCSS(lcss); + emb.getData(m_dmrFrame); + + rx_dmrdata.setData(m_dmrFrame); + + //CUtils::dump(1U, "DMR data:", m_dmrFrame, 33U); + m_dmrNetwork->write(rx_dmrdata); + + n_dmr++; + dmr_cnt++; + } + } + + rx_dmrdata.setSlotNo(2U); + rx_dmrdata.setSrcId(m_dmrSrc); + rx_dmrdata.setDstId(m_dmrDst); + rx_dmrdata.setFLCO(m_dmrflco); + rx_dmrdata.setN(n_dmr); + rx_dmrdata.setSeqNo(dmr_cnt); + rx_dmrdata.setBER(0U); + rx_dmrdata.setRSSI(0U); + rx_dmrdata.setDataType(DT_TERMINATOR_WITH_LC); + + // Add sync + CSync::addDMRDataSync(m_dmrFrame, 0); + + // Add SlotType + CDMRSlotType slotType; + slotType.setColorCode(m_colorcode); + slotType.setDataType(DT_TERMINATOR_WITH_LC); + slotType.getData(m_dmrFrame); + + // Full LC + CDMRLC dmrLC = CDMRLC(m_dmrflco, m_dmrSrc, m_dmrDst); + CDMRFullLC fullLC; + fullLC.encode(dmrLC, m_dmrFrame, DT_TERMINATOR_WITH_LC); + + rx_dmrdata.setData(m_dmrFrame); + //CUtils::dump(1U, "DMR data:", m_dmrFrame, 33U); + m_dmrNetwork->write(rx_dmrdata); + + dmrWatch.start(); + } + else if(dmrFrameType == TAG_DATA) { + CDMREMB emb; + CDMRData rx_dmrdata; + unsigned int n_dmr = (dmr_cnt - 3U) % 6U; + + rx_dmrdata.setSlotNo(2U); + rx_dmrdata.setSrcId(m_dmrSrc); + rx_dmrdata.setDstId(m_dmrDst); + rx_dmrdata.setFLCO(m_dmrflco); + rx_dmrdata.setN(n_dmr); + rx_dmrdata.setSeqNo(dmr_cnt); + rx_dmrdata.setBER(0U); + rx_dmrdata.setRSSI(0U); + + if (!n_dmr) { + rx_dmrdata.setDataType(DT_VOICE_SYNC); + // Add sync + CSync::addDMRAudioSync(m_dmrFrame, 0U); + // Prepare Full LC data + CDMRLC dmrLC = CDMRLC(m_dmrflco, m_dmrSrc, m_dmrDst); + // Configure the Embedded LC + m_EmbeddedLC.setLC(dmrLC); + } + else { + rx_dmrdata.setDataType(DT_VOICE); + // Generate the Embedded LC + unsigned char lcss = m_EmbeddedLC.getData(m_dmrFrame, n_dmr); + // Generate the EMB + emb.setColorCode(m_colorcode); + emb.setLCSS(lcss); + emb.getData(m_dmrFrame); + } + + rx_dmrdata.setData(m_dmrFrame); + + //CUtils::dump(1U, "DMR data:", m_dmrFrame, 33U); + m_dmrNetwork->write(rx_dmrdata); + + dmr_cnt++; + dmrWatch.start(); + } + } + + while (m_dmrNetwork->read(tx_dmrdata) > 0U) { + m_dmrSrc = tx_dmrdata.getSrcId(); + m_dmrDst = tx_dmrdata.getDstId(); + + memset(m17_src, 0, 10); + std::string css = m_dmrlookup->findCS(m_dmrSrc); + memcpy(m17_src, css.c_str(), css.size()); + m17_src[css.size()] = ' '; + m17_src[css.size()+1] = 'D'; + encode_callsign(m17_src); + //fprintf(stderr, "M17 Callsign info %s : %s : %d\n", m17_src, css.c_str(), m_dmrSrc); + + FLCO netflco = tx_dmrdata.getFLCO(); + unsigned char DataType = tx_dmrdata.getDataType(); + + if (!tx_dmrdata.isMissing()) { + networkWatchdog.start(); + + if(DataType == DT_TERMINATOR_WITH_LC && m_dmrFrames > 0U) { + LogMessage("DMR received end of voice transmission, %.1f seconds", float(m_dmrFrames) / 16.667F); + + m_conv.putDMREOT(); + networkWatchdog.stop(); + m_dmrFrames = 0U; + m_dmrinfo = false; + } + + if((DataType == DT_VOICE_LC_HEADER) && (DataType != m_dmrLastDT)) { + std::string netSrc = m_dmrlookup->findCS(m_dmrSrc); + std::string netDst = (netflco == FLCO_GROUP ? "TG " : "") + m_dmrlookup->findCS(m_dmrDst); + + m_conv.putDMRHeader(); + LogMessage("DMR header received from %s to %s", netSrc.c_str(), netDst.c_str()); + + m_dmrinfo = true; + + m_dmrFrames = 0U; + } + + if(DataType == DT_VOICE_SYNC || DataType == DT_VOICE) { + unsigned char dmr_frame[50]; + tx_dmrdata.getData(dmr_frame); + m_conv.putDMR(dmr_frame); + m_dmrFrames++; + } + } + else { + if(DataType == DT_VOICE_SYNC || DataType == DT_VOICE) { + unsigned char dmr_frame[50]; + tx_dmrdata.getData(dmr_frame); + + if (!m_dmrinfo) { + std::string netSrc = m_dmrlookup->findCS(m_dmrSrc); + std::string netDst = (netflco == FLCO_GROUP ? "TG " : "") + m_dmrlookup->findCS(m_dmrDst); + + m_conv.putDMRHeader(); + LogMessage("DMR late entry from %s to %s", netSrc.c_str(), netDst.c_str()); + + m_dmrinfo = true; + } + + m_conv.putDMR(dmr_frame); + m_dmrFrames++; + } + + networkWatchdog.clock(ms); + if (networkWatchdog.hasExpired()) { + LogDebug("Network watchdog has expired, %.1f seconds", float(m_dmrFrames) / 16.667F); + networkWatchdog.stop(); + m_dmrFrames = 0U; + m_dmrinfo = false; + } + } + + m_dmrLastDT = DataType; + } + + stopWatch.start(); + + m_dmrNetwork->clock(ms); + pollTimer.clock(ms); + if (pollTimer.isRunning() && pollTimer.hasExpired()) { + m_m17Network->writePoll(); + pollTimer.start(); + } + + + } + + m_m17Network->close(); + m_dmrNetwork->close(); + delete m_dmrNetwork; + delete m_m17Network; + + ::LogFinalise(); + + return 0; +} + +bool CDMR2M17::createMMDVM() +{ + std::string rptAddress = m_conf.getDMRRptAddress(); + unsigned int rptPort = m_conf.getDMRRptPort(); + std::string localAddress = m_conf.getDMRLocalAddress(); + unsigned int localPort = m_conf.getDMRLocalPort(); + bool debug = m_conf.getDMRDebug(); + + LogInfo("MMDVM Network Parameters"); + LogInfo(" Rpt Address: %s", rptAddress.c_str()); + LogInfo(" Rpt Port: %u", rptPort); + LogInfo(" Local Address: %s", localAddress.c_str()); + LogInfo(" Local Port: %u", localPort); + + m_dmrNetwork = new CMMDVMNetwork(rptAddress, rptPort, localAddress, localPort, debug); + + bool ret = m_dmrNetwork->open(); + if (!ret) { + delete m_dmrNetwork; + m_dmrNetwork = NULL; + return false; + } + + return true; +} diff --git a/DMR2M17/DMR2M17.h b/DMR2M17/DMR2M17.h new file mode 100644 index 0000000..5aef33e --- /dev/null +++ b/DMR2M17/DMR2M17.h @@ -0,0 +1,84 @@ +/* +* Copyright (C) 2016 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* Copyright (C) 2020 by Doug McLain AD8DP +* +* 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(DMR2M17_H) +#define DMR2M17_H + +#include "DMRDefines.h" +#include "ModeConv.h" +#include "MMDVMNetwork.h" +#include "DMREmbeddedData.h" +#include "DMRLC.h" +#include "DMRFullLC.h" +#include "DMREMB.h" +#include "DMRLookup.h" +#include "M17Network.h" +#include "UDPSocket.h" +#include "StopWatch.h" +#include "Version.h" +#include "Thread.h" +#include "Timer.h" +#include "Sync.h" +#include "Utils.h" +#include "Conf.h" +#include "Log.h" +#include "CRC.h" + +#include + +class CDMR2M17 +{ +public: + CDMR2M17(const std::string& configFile); + ~CDMR2M17(); + + int run(); + +private: + std::string m_callsign; + std::string m_m17Ref; + CConf m_conf; + CMMDVMNetwork* m_dmrNetwork; + CM17Network* m_m17Network; + CDMRLookup* m_dmrlookup; + CModeConv m_conv; + unsigned int m_colorcode; + unsigned int m_dstid; + unsigned int m_dmrSrc; + unsigned int m_dmrDst; + unsigned char m_dmrLastDT; + unsigned char* m_dmrFrame; + unsigned int m_dmrFrames; + std::string m_m17Src; + std::string m_m17Dst; + unsigned char* m_m17Frame; + unsigned int m_m17Frames; + CDMREmbeddedData m_EmbeddedLC; + FLCO m_dmrflco; + bool m_dmrinfo; + unsigned char* m_config; + unsigned int m_configLen; + + unsigned int truncID(unsigned int id); + bool createMMDVM(); + +}; + +#endif diff --git a/DMR2M17/DMR2M17.ini b/DMR2M17/DMR2M17.ini new file mode 100644 index 0000000..5f08272 --- /dev/null +++ b/DMR2M17/DMR2M17.ini @@ -0,0 +1,29 @@ +[M17 Network] +Callsign=AD8DP D +LocalAddress=127.0.0.1 +LocalPort=32010 +DstAddress=192.168.1.8 +DstPort=17000 +GainAdjustdB=-26 +Daemon=0 +Debug=1 + +[DMR Network] +Id=3126482 +RptAddress=127.0.0.1 +RptPort=62032 +LocalAddress=127.0.0.4 +LocalPort=62037 +Debug=1 + +[DMR Id Lookup] +File=DMRIds.dat +Time=24 + +[Log] +# Logging levels, 0=No logging +DisplayLevel=1 +FileLevel=1 +FilePath=. +FileRoot=DMR2M17 + diff --git a/DMR2M17/DMRData.cpp b/DMR2M17/DMRData.cpp new file mode 100644 index 0000000..200b318 --- /dev/null +++ b/DMR2M17/DMRData.cpp @@ -0,0 +1,211 @@ +/* + * Copyright (C) 2015,2016,2017 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_missing(data.m_missing), +m_n(data.m_n), +m_ber(data.m_ber), +m_rssi(data.m_rssi), +m_streamId(data.m_streamId) +{ + 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_missing(false), +m_n(0U), +m_ber(0U), +m_rssi(0U), +m_streamId(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_missing = data.m_missing; + m_n = data.m_n; + m_ber = data.m_ber; + m_rssi = data.m_rssi; + m_streamId = data.m_streamId; + } + + 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; +} + +bool CDMRData::isMissing() const +{ + return m_missing; +} + +void CDMRData::setMissing(bool missing) +{ + m_missing = missing; +} + +unsigned char CDMRData::getN() const +{ + return m_n; +} + +void CDMRData::setN(unsigned char n) +{ + m_n = n; +} + +unsigned char CDMRData::getBER() const +{ + return m_ber; +} + +void CDMRData::setBER(unsigned char ber) +{ + m_ber = ber; +} + +unsigned char CDMRData::getRSSI() const +{ + return m_rssi; +} + +void CDMRData::setRSSI(unsigned char rssi) +{ + m_rssi = rssi; +} + +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); +} + +unsigned int CDMRData::getStreamId() const +{ + return m_streamId; +} + +void CDMRData::setStreamId(unsigned int id) +{ + m_streamId = id; +} diff --git a/DMR2M17/DMRData.h b/DMR2M17/DMRData.h new file mode 100644 index 0000000..ed0ea55 --- /dev/null +++ b/DMR2M17/DMRData.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2015,2016,2017 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); + + bool isMissing() const; + void setMissing(bool missing); + + unsigned char getBER() const; + void setBER(unsigned char ber); + + unsigned char getRSSI() const; + void setRSSI(unsigned char rssi); + + void setData(const unsigned char* buffer); + unsigned int getData(unsigned char* buffer) const; + + void setStreamId(unsigned int id); + unsigned int getStreamId() 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; + bool m_missing; + unsigned char m_n; + unsigned char m_ber; + unsigned char m_rssi; + unsigned int m_streamId; +}; + +#endif diff --git a/DMR2M17/DMRDefines.h b/DMR2M17/DMRDefines.h new file mode 100644 index 0000000..4cd7ae2 --- /dev/null +++ b/DMR2M17/DMRDefines.h @@ -0,0 +1,122 @@ +/* + * 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 + +#include "Defines.h" // For TAG_DATA + +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 DMR_IDLE_DATA[] = {TAG_DATA, 0x00U, + 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}; + +// A silence frame only +const unsigned char DMR_SILENCE_DATA[] = {0xB9U, 0xE8U, 0x81U, 0x52U, 0x61U, 0x73U, 0x00U, 0x2AU, 0x6BU, 0xB9U, 0xE8U, + 0x81U, 0x52U, 0x60U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x01U, 0x73U, 0x00U, + 0x2AU, 0x6BU, 0xB9U, 0xE8U, 0x81U, 0x52U, 0x61U, 0x73U, 0x00U, 0x2AU, 0x6BU}; + +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 PI_HEADER_CRC_MASK[] = {0x69U, 0x69U}; +const unsigned char DATA_HEADER_CRC_MASK[] = {0xCCU, 0xCCU}; +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_RATE_12_DATA = 0x07U; +const unsigned char DT_RATE_34_DATA = 0x08U; +const unsigned char DT_IDLE = 0x09U; +const unsigned char DT_RATE_1_DATA = 0x0AU; + +// 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 DPF_UDT = 0x00U; +const unsigned char DPF_RESPONSE = 0x01U; +const unsigned char DPF_UNCONFIRMED_DATA = 0x02U; +const unsigned char DPF_CONFIRMED_DATA = 0x03U; +const unsigned char DPF_DEFINED_SHORT = 0x0DU; +const unsigned char DPF_DEFINED_RAW = 0x0EU; +const unsigned char DPF_PROPRIETARY = 0x0FU; + +const unsigned char FID_ETSI = 0U; +const unsigned char FID_DMRA = 16U; + +enum FLCO { + FLCO_GROUP = 0, + FLCO_USER_USER = 3, + FLCO_TALKER_ALIAS_HEADER = 4, + FLCO_TALKER_ALIAS_BLOCK1 = 5, + FLCO_TALKER_ALIAS_BLOCK2 = 6, + FLCO_TALKER_ALIAS_BLOCK3 = 7, + FLCO_GPS_INFO = 8 +}; + +#endif diff --git a/DMR2M17/DMREMB.cpp b/DMR2M17/DMREMB.cpp new file mode 100644 index 0000000..f60c7be --- /dev/null +++ b/DMR2M17/DMREMB.cpp @@ -0,0 +1,100 @@ +/* + * 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 "DMREMB.h" + +#include "QR1676.h" + +#include +#include + +CDMREMB::CDMREMB() : +m_colorCode(0U), +m_PI(false), +m_LCSS(0U) +{ +} + +CDMREMB::~CDMREMB() +{ +} + +void CDMREMB::putData(const unsigned char* data) +{ + assert(data != NULL); + + unsigned char DMREMB[2U]; + DMREMB[0U] = (data[13U] << 4) & 0xF0U; + DMREMB[0U] |= (data[14U] >> 4) & 0x0FU; + DMREMB[1U] = (data[18U] << 4) & 0xF0U; + DMREMB[1U] |= (data[19U] >> 4) & 0x0FU; + + CQR1676::decode(DMREMB); + + m_colorCode = (DMREMB[0U] >> 4) & 0x0FU; + m_PI = (DMREMB[0U] & 0x08U) == 0x08U; + m_LCSS = (DMREMB[0U] >> 1) & 0x03U; +} + +void CDMREMB::getData(unsigned char* data) const +{ + assert(data != NULL); + + unsigned char DMREMB[2U]; + DMREMB[0U] = (m_colorCode << 4) & 0xF0U; + DMREMB[0U] |= m_PI ? 0x08U : 0x00U; + DMREMB[0U] |= (m_LCSS << 1) & 0x06U; + DMREMB[1U] = 0x00U; + + CQR1676::encode(DMREMB); + + data[13U] = (data[13U] & 0xF0U) | ((DMREMB[0U] >> 4U) & 0x0FU); + data[14U] = (data[14U] & 0x0FU) | ((DMREMB[0U] << 4U) & 0xF0U); + data[18U] = (data[18U] & 0xF0U) | ((DMREMB[1U] >> 4U) & 0x0FU); + data[19U] = (data[19U] & 0x0FU) | ((DMREMB[1U] << 4U) & 0xF0U); +} + +unsigned char CDMREMB::getColorCode() const +{ + return m_colorCode; +} + +void CDMREMB::setColorCode(unsigned char code) +{ + m_colorCode = code; +} + +bool CDMREMB::getPI() const +{ + return m_PI; +} + +void CDMREMB::setPI(bool pi) +{ + m_PI = pi; +} + +unsigned char CDMREMB::getLCSS() const +{ + return m_LCSS; +} + +void CDMREMB::setLCSS(unsigned char lcss) +{ + m_LCSS = lcss; +} diff --git a/DMR2M17/DMREMB.h b/DMR2M17/DMREMB.h new file mode 100644 index 0000000..517be1e --- /dev/null +++ b/DMR2M17/DMREMB.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(DMREMB_H) +#define DMREMB_H + +class CDMREMB +{ +public: + CDMREMB(); + ~CDMREMB(); + + 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/DMR2M17/DMREmbeddedData.cpp b/DMR2M17/DMREmbeddedData.cpp new file mode 100644 index 0000000..a5a3e42 --- /dev/null +++ b/DMR2M17/DMREmbeddedData.cpp @@ -0,0 +1,322 @@ +/* + * Copyright (C) 2015,2016,2017 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 "DMREmbeddedData.h" + +#include "Hamming.h" +#include "Utils.h" +#include "CRC.h" + +#include +#include +#include + +CDMREmbeddedData::CDMREmbeddedData() : +m_raw(NULL), +m_state(LCS_NONE), +m_data(NULL), +m_FLCO(FLCO_GROUP), +m_valid(false) +{ + m_raw = new bool[128U]; + m_data = new bool[72U]; +} + +CDMREmbeddedData::~CDMREmbeddedData() +{ + delete[] m_raw; + delete[] m_data; +} + +// Add LC data (which may consist of 4 blocks) to the data store +bool CDMREmbeddedData::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_raw[a] = rawData[a + 4U]; + + // Show we are ready for the next LC block + m_state = LCS_FIRST; + m_valid = false; + + return false; + } + + // 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_raw[a + 32U] = rawData[a + 4U]; + + // Show we are ready for the next LC block + m_state = LCS_SECOND; + + return false; + } + + // 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_raw[a + 64U] = rawData[a + 4U]; + + // Show we are ready for the final LC block + m_state = LCS_THIRD; + + return false; + } + + // 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_raw[a + 96U] = rawData[a + 4U]; + + // Show that we're not ready for any more data + m_state = LCS_NONE; + + // Process the complete data block + decodeEmbeddedData(); + if (m_valid) + encodeEmbeddedData(); + + return m_valid; + } + + return false; +} + +void CDMREmbeddedData::setLC(const CDMRLC& lc) +{ + lc.getData(m_data); + + m_FLCO = lc.getFLCO(); + m_valid = true; + + encodeEmbeddedData(); +} + +void CDMREmbeddedData::encodeEmbeddedData() +{ + unsigned int crc; + CCRC::encodeFiveBit(m_data, 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] = m_data[b]; + for (unsigned int a = 16U; a < 27U; a++, b++) + data[a] = m_data[b]; + for (unsigned int a = 32U; a < 42U; a++, b++) + data[a] = m_data[b]; + for (unsigned int a = 48U; a < 58U; a++, b++) + data[a] = m_data[b]; + for (unsigned int a = 64U; a < 74U; a++, b++) + data[a] = m_data[b]; + for (unsigned int a = 80U; a < 90U; a++, b++) + data[a] = m_data[b]; + for (unsigned int a = 96U; a < 106U; a++, b++) + data[a] = m_data[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_raw[a] = data[b]; + b += 16U; + if (b > 127U) + b -= 127U; + } +} + +unsigned char CDMREmbeddedData::getData(unsigned char* data, unsigned char n) const +{ + assert(data != NULL); + + if (n >= 1U && n < 5U) { + n--; + + bool bits[40U]; + ::memset(bits, 0x00U, 40U * sizeof(bool)); + ::memcpy(bits + 4U, m_raw + 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); + + switch (n) { + case 0U: + return 1U; + case 3U: + return 2U; + default: + return 3U; + } + } else { + data[14U] &= 0xF0U; + data[15U] = 0x00U; + data[16U] = 0x00U; + data[17U] = 0x00U; + data[18U] &= 0x0FU; + + return 0U; + } +} + +// Unpack and error check an embedded LC +void CDMREmbeddedData::decodeEmbeddedData() +{ + // 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_raw[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)) + return; + } + + // 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) + return; + } + + // We have passed the Hamming check so extract the actual payload + b = 0U; + for (unsigned int a = 0U; a < 11U; a++, b++) + m_data[b] = data[a]; + for (unsigned int a = 16U; a < 27U; a++, b++) + m_data[b] = data[a]; + for (unsigned int a = 32U; a < 42U; a++, b++) + m_data[b] = data[a]; + for (unsigned int a = 48U; a < 58U; a++, b++) + m_data[b] = data[a]; + for (unsigned int a = 64U; a < 74U; a++, b++) + m_data[b] = data[a]; + for (unsigned int a = 80U; a < 90U; a++, b++) + m_data[b] = data[a]; + for (unsigned int a = 96U; a < 106U; a++, b++) + m_data[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(m_data, crc)) + return; + + m_valid = true; + + // Extract the FLCO + unsigned char flco; + CUtils::bitsToByteBE(m_data + 0U, flco); + m_FLCO = FLCO(flco & 0x3FU); +} + +CDMRLC* CDMREmbeddedData::getLC() const +{ + if (!m_valid) + return NULL; + + if (m_FLCO != FLCO_GROUP && m_FLCO != FLCO_USER_USER) + return NULL; + + return new CDMRLC(m_data); +} + +bool CDMREmbeddedData::isValid() const +{ + return m_valid; +} + +FLCO CDMREmbeddedData::getFLCO() const +{ + return m_FLCO; +} + +void CDMREmbeddedData::reset() +{ + m_state = LCS_NONE; + m_valid = false; +} + +bool CDMREmbeddedData::getRawData(unsigned char* data) const +{ + assert(data != NULL); + + if (!m_valid) + return false; + + CUtils::bitsToByteBE(m_data + 0U, data[0U]); + CUtils::bitsToByteBE(m_data + 8U, data[1U]); + CUtils::bitsToByteBE(m_data + 16U, data[2U]); + CUtils::bitsToByteBE(m_data + 24U, data[3U]); + CUtils::bitsToByteBE(m_data + 32U, data[4U]); + CUtils::bitsToByteBE(m_data + 40U, data[5U]); + CUtils::bitsToByteBE(m_data + 48U, data[6U]); + CUtils::bitsToByteBE(m_data + 56U, data[7U]); + CUtils::bitsToByteBE(m_data + 64U, data[8U]); + + return true; +} diff --git a/DMR2M17/DMREmbeddedData.h b/DMR2M17/DMREmbeddedData.h new file mode 100644 index 0000000..7222dcd --- /dev/null +++ b/DMR2M17/DMREmbeddedData.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2015,2016,2017 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 DMREmbeddedData_H +#define DMREmbeddedData_H + +#include "DMRDefines.h" +#include "DMRLC.h" + +enum LC_STATE { + LCS_NONE, + LCS_FIRST, + LCS_SECOND, + LCS_THIRD +}; + +class CDMREmbeddedData +{ +public: + CDMREmbeddedData(); + ~CDMREmbeddedData(); + + bool addData(const unsigned char* data, unsigned char lcss); + + CDMRLC* getLC() const; + void setLC(const CDMRLC& lc); + + unsigned char getData(unsigned char* data, unsigned char n) const; + + bool getRawData(unsigned char* data) const; + + bool isValid() const; + FLCO getFLCO() const; + + void reset(); + +private: + bool* m_raw; + LC_STATE m_state; + bool* m_data; + FLCO m_FLCO; + bool m_valid; + + void decodeEmbeddedData(); + void encodeEmbeddedData(); +}; + +#endif diff --git a/DMR2M17/DMRFullLC.cpp b/DMR2M17/DMRFullLC.cpp new file mode 100644 index 0000000..dbcd6cc --- /dev/null +++ b/DMR2M17/DMRFullLC.cpp @@ -0,0 +1,99 @@ +/* + * 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 "DMRFullLC.h" + +#include "DMRDefines.h" +#include "RS129.h" +#include "Utils.h" +#include "Log.h" + +#include +#include + +CDMRFullLC::CDMRFullLC() : +m_bptc() +{ +} + +CDMRFullLC::~CDMRFullLC() +{ +} + +CDMRLC* CDMRFullLC::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)) + return NULL; + + return new CDMRLC(lcData); +} + +void CDMRFullLC::encode(const CDMRLC& 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/DMR2M17/DMRFullLC.h b/DMR2M17/DMRFullLC.h new file mode 100644 index 0000000..d3294ef --- /dev/null +++ b/DMR2M17/DMRFullLC.h @@ -0,0 +1,42 @@ +/* + * 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. + */ + +#ifndef DMRFullLC_H +#define DMRFullLC_H + +#include "DMRLC.h" +#include "DMRSlotType.h" + +#include "BPTC19696.h" + +class CDMRFullLC +{ +public: + CDMRFullLC(); + ~CDMRFullLC(); + + CDMRLC* decode(const unsigned char* data, unsigned char type); + + void encode(const CDMRLC& lc, unsigned char* data, unsigned char type); + +private: + CBPTC19696 m_bptc; +}; + +#endif + diff --git a/DMR2M17/DMRLC.cpp b/DMR2M17/DMRLC.cpp new file mode 100644 index 0000000..8dd897b --- /dev/null +++ b/DMR2M17/DMRLC.cpp @@ -0,0 +1,205 @@ +/* + * 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 "DMRLC.h" + +#include "Utils.h" + +#include +#include + +CDMRLC::CDMRLC(FLCO flco, unsigned int srcId, unsigned int dstId) : +m_PF(false), +m_R(false), +m_FLCO(flco), +m_FID(0U), +m_options(0U), +m_srcId(srcId), +m_dstId(dstId) +{ +} + +CDMRLC::CDMRLC(const unsigned char* bytes) : +m_PF(false), +m_R(false), +m_FLCO(FLCO_GROUP), +m_FID(0U), +m_options(0U), +m_srcId(0U), +m_dstId(0U) +{ + assert(bytes != NULL); + + m_PF = (bytes[0U] & 0x80U) == 0x80U; + m_R = (bytes[0U] & 0x40U) == 0x40U; + + m_FLCO = FLCO(bytes[0U] & 0x3FU); + + m_FID = bytes[1U]; + + m_options = bytes[2U]; + + m_dstId = bytes[3U] << 16 | bytes[4U] << 8 | bytes[5U]; + m_srcId = bytes[6U] << 16 | bytes[7U] << 8 | bytes[8U]; +} + +CDMRLC::CDMRLC(const bool* bits) : +m_PF(false), +m_R(false), +m_FLCO(FLCO_GROUP), +m_FID(0U), +m_options(0U), +m_srcId(0U), +m_dstId(0U) +{ + assert(bits != NULL); + + m_PF = bits[0U]; + m_R = bits[1U]; + + unsigned char temp1, temp2, temp3; + CUtils::bitsToByteBE(bits + 0U, temp1); + m_FLCO = FLCO(temp1 & 0x3FU); + + CUtils::bitsToByteBE(bits + 8U, temp2); + m_FID = temp2; + + CUtils::bitsToByteBE(bits + 16U, temp3); + m_options = temp3; + + 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; +} + +CDMRLC::CDMRLC() : +m_PF(false), +m_R(false), +m_FLCO(FLCO_GROUP), +m_FID(0U), +m_options(0U), +m_srcId(0U), +m_dstId(0U) +{ +} + +CDMRLC::~CDMRLC() +{ +} + +void CDMRLC::getData(unsigned char* bytes) const +{ + assert(bytes != NULL); + + bytes[0U] = (unsigned char)m_FLCO; + + if (m_PF) + bytes[0U] |= 0x80U; + + if (m_R) + bytes[0U] |= 0x40U; + + bytes[1U] = m_FID; + + bytes[2U] = m_options; + + 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 CDMRLC::getData(bool* bits) const +{ + assert(bits != NULL); + + 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 CDMRLC::getPF() const +{ + return m_PF; +} + +void CDMRLC::setPF(bool pf) +{ + m_PF = pf; +} + +FLCO CDMRLC::getFLCO() const +{ + return m_FLCO; +} + +void CDMRLC::setFLCO(FLCO flco) +{ + m_FLCO = flco; +} + +unsigned char CDMRLC::getFID() const +{ + return m_FID; +} + +void CDMRLC::setFID(unsigned char fid) +{ + m_FID = fid; +} + +unsigned int CDMRLC::getSrcId() const +{ + return m_srcId; +} + +void CDMRLC::setSrcId(unsigned int id) +{ + m_srcId = id; +} + +unsigned int CDMRLC::getDstId() const +{ + return m_dstId; +} + +void CDMRLC::setDstId(unsigned int id) +{ + m_dstId = id; +} diff --git a/DMR2M17/DMRLC.h b/DMR2M17/DMRLC.h new file mode 100644 index 0000000..9f3a464 --- /dev/null +++ b/DMR2M17/DMRLC.h @@ -0,0 +1,62 @@ +/* + * 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(DMRLC_H) +#define DMRLC_H + +#include "DMRDefines.h" + +class CDMRLC +{ +public: + CDMRLC(FLCO flco, unsigned int srcId, unsigned int dstId); + CDMRLC(const unsigned char* bytes); + CDMRLC(const bool* bits); + CDMRLC(); + ~CDMRLC(); + + 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; + bool m_R; + FLCO m_FLCO; + unsigned char m_FID; + unsigned char m_options; + unsigned int m_srcId; + unsigned int m_dstId; +}; + +#endif + diff --git a/DMR2M17/DMRLookup.cpp b/DMR2M17/DMRLookup.cpp new file mode 100644 index 0000000..f8e48e4 --- /dev/null +++ b/DMR2M17/DMRLookup.cpp @@ -0,0 +1,179 @@ +/* +* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* +* 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 "DMRLookup.h" +#include "Timer.h" +#include "Log.h" + +#include +#include +#include +#include + +CDMRLookup::CDMRLookup(const std::string& filename, unsigned int reloadTime) : +CThread(), +m_filename(filename), +m_reloadTime(reloadTime), +m_table(), +m_cstable(), +m_mutex(), +m_stop(false) +{ +} + +CDMRLookup::~CDMRLookup() +{ +} + +bool CDMRLookup::read() +{ + bool ret = load(); + + if (m_reloadTime > 0U) + run(); + + return ret; +} + +void CDMRLookup::entry() +{ + LogInfo("Started the DMR Id lookup reload thread"); + + CTimer timer(1U, 3600U * m_reloadTime); + timer.start(); + + while (!m_stop) { + sleep(1000U); + + timer.clock(); + if (timer.hasExpired()) { + load(); + timer.start(); + } + } + + LogInfo("Stopped the DMR Id lookup reload thread"); +} + +void CDMRLookup::stop() +{ + if (m_reloadTime == 0U) { + delete this; + return; + } + + m_stop = true; + + wait(); +} + +std::string CDMRLookup::findCS(unsigned int id) +{ + std::string callsign; + + if (id == 0xFFFFFFU) + return std::string("ALL"); + + m_mutex.lock(); + + try { + callsign = m_table.at(id); + } catch (...) { + char text[10U]; + ::sprintf(text, "%u", id); + callsign = std::string(text); + } + + m_mutex.unlock(); + + return callsign; +} + +unsigned int CDMRLookup::findID(std::string cs) +{ + unsigned int dmrID; + + m_mutex.lock(); + + try { + dmrID = m_cstable.at(cs); + } catch (...) { + dmrID = 0U; + } + + m_mutex.unlock(); + + return dmrID; +} + +bool CDMRLookup::exists(unsigned int id) +{ + m_mutex.lock(); + + bool found = m_table.count(id) == 1U; + + m_mutex.unlock(); + + return found; +} + +bool CDMRLookup::load() +{ + FILE* fp = ::fopen(m_filename.c_str(), "rt"); + if (fp == NULL) { + LogWarning("Cannot open the DMR Id lookup file - %s", m_filename.c_str()); + return false; + } + + m_mutex.lock(); + + // Remove the old entries + m_table.clear(); + m_cstable.clear(); + + char buffer[100U]; + while (::fgets(buffer, 100U, fp) != NULL) { + if (buffer[0U] == '#') + continue; + + char* p1 = ::strtok(buffer, " \t\r\n"); + char* p2 = ::strtok(NULL, " \t\r\n"); + + if (p1 != NULL && p2 != NULL) { + unsigned int id = (unsigned int)::atoi(p1); + for (char* p = p2; *p != 0x00U; p++) + *p = ::toupper(*p); + + m_table[id] = std::string(p2); + m_cstable[p2] = id; + } + } + + m_mutex.unlock(); + + ::fclose(fp); + + size_t size = m_table.size(); + if (size == 0U) + return false; + + LogInfo("Loaded %u Ids to the DMR callsign lookup table", size); + + return true; +} \ No newline at end of file diff --git a/DMR2M17/DMRLookup.h b/DMR2M17/DMRLookup.h new file mode 100644 index 0000000..1bcbfae --- /dev/null +++ b/DMR2M17/DMRLookup.h @@ -0,0 +1,56 @@ +/* +* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* +* 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 DMRLookup_H +#define DMRLookup_H + +#include "Thread.h" +#include "Mutex.h" + +#include +#include + +class CDMRLookup : public CThread { +public: + CDMRLookup(const std::string& filename, unsigned int reloadTime); + virtual ~CDMRLookup(); + + bool read(); + + virtual void entry(); + + std::string findCS(unsigned int id); + unsigned int findID(std::string cs); + + bool exists(unsigned int id); + + void stop(); + +private: + std::string m_filename; + unsigned int m_reloadTime; + std::unordered_map m_table; + std::unordered_map m_cstable; + CMutex m_mutex; + bool m_stop; + + bool load(); +}; + +#endif diff --git a/DMR2M17/DMRSlotType.cpp b/DMR2M17/DMRSlotType.cpp new file mode 100644 index 0000000..d855303 --- /dev/null +++ b/DMR2M17/DMRSlotType.cpp @@ -0,0 +1,92 @@ +/* + * 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 "DMRSlotType.h" + +#include "Golay2087.h" + +#include +#include + +CDMRSlotType::CDMRSlotType() : +m_colorCode(0U), +m_dataType(0U) +{ +} + +CDMRSlotType::~CDMRSlotType() +{ +} + +void CDMRSlotType::putData(const unsigned char* data) +{ + assert(data != NULL); + + unsigned char DMRSlotType[3U]; + DMRSlotType[0U] = (data[12U] << 2) & 0xFCU; + DMRSlotType[0U] |= (data[13U] >> 6) & 0x03U; + + DMRSlotType[1U] = (data[13U] << 2) & 0xC0U; + DMRSlotType[1U] |= (data[19U] << 2) & 0x3CU; + DMRSlotType[1U] |= (data[20U] >> 6) & 0x03U; + + DMRSlotType[2U] = (data[20U] << 2) & 0xF0U; + + unsigned char code = CGolay2087::decode(DMRSlotType); + + m_colorCode = (code >> 4) & 0x0FU; + m_dataType = (code >> 0) & 0x0FU; +} + +void CDMRSlotType::getData(unsigned char* data) const +{ + assert(data != NULL); + + unsigned char DMRSlotType[3U]; + DMRSlotType[0U] = (m_colorCode << 4) & 0xF0U; + DMRSlotType[0U] |= (m_dataType << 0) & 0x0FU; + DMRSlotType[1U] = 0x00U; + DMRSlotType[2U] = 0x00U; + + CGolay2087::encode(DMRSlotType); + + data[12U] = (data[12U] & 0xC0U) | ((DMRSlotType[0U] >> 2) & 0x3FU); + data[13U] = (data[13U] & 0x0FU) | ((DMRSlotType[0U] << 6) & 0xC0U) | ((DMRSlotType[1U] >> 2) & 0x30U); + data[19U] = (data[19U] & 0xF0U) | ((DMRSlotType[1U] >> 2) & 0x0FU); + data[20U] = (data[20U] & 0x03U) | ((DMRSlotType[1U] << 6) & 0xC0U) | ((DMRSlotType[2U] >> 2) & 0x3CU); +} + +unsigned char CDMRSlotType::getColorCode() const +{ + return m_colorCode; +} + +void CDMRSlotType::setColorCode(unsigned char code) +{ + m_colorCode = code; +} + +unsigned char CDMRSlotType::getDataType() const +{ + return m_dataType; +} + +void CDMRSlotType::setDataType(unsigned char type) +{ + m_dataType = type; +} diff --git a/DMR2M17/DMRSlotType.h b/DMR2M17/DMRSlotType.h new file mode 100644 index 0000000..e76821f --- /dev/null +++ b/DMR2M17/DMRSlotType.h @@ -0,0 +1,42 @@ +/* + * 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(DMRSLOTTYPE_H) +#define DMRSLOTTYPE_H + +class CDMRSlotType +{ +public: + CDMRSlotType(); + ~CDMRSlotType(); + + 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/DMR2M17/Defines.h b/DMR2M17/Defines.h new file mode 100644 index 0000000..1da97d3 --- /dev/null +++ b/DMR2M17/Defines.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2015,2016,2017 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 MODE_P25 = 4U; +const unsigned char MODE_NXDN = 5U; +const unsigned char MODE_CW = 98U; +const unsigned char MODE_LOCKOUT = 99U; +const unsigned char MODE_ERROR = 100U; + +const unsigned char TAG_HEADER = 0x00U; +const unsigned char TAG_DATA = 0x01U; +const unsigned char TAG_LOST = 0x02U; +const unsigned char TAG_EOT = 0x03U; +const unsigned char TAG_NODATA = 0x04U; + +enum HW_TYPE { + HWT_MMDVM, + HWT_DVMEGA, + HWT_MMDVM_ZUMSPOT, + HWT_MMDVM_HS_HAT, + HWT_NANO_HOTSPOT, + HWT_MMDVM_HS, + HWT_UNKNOWN +}; + +enum RPT_RF_STATE { + RS_RF_LISTENING, + RS_RF_LATE_ENTRY, + RS_RF_AUDIO, + RS_RF_DATA, + RS_RF_REJECTED, + RS_RF_INVALID +}; + +enum RPT_NET_STATE { + RS_NET_IDLE, + RS_NET_AUDIO, + RS_NET_DATA +}; + +enum B_STATUS { + BS_NO_DATA, + BS_DATA, + BS_MISSING +}; + +#endif diff --git a/DMR2M17/DelayBuffer.cpp b/DMR2M17/DelayBuffer.cpp new file mode 100644 index 0000000..36e480c --- /dev/null +++ b/DMR2M17/DelayBuffer.cpp @@ -0,0 +1,159 @@ +/* +* Copyright (C) 2018 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 "DelayBuffer.h" +#include "DMRDefines.h" + +#include "Log.h" + +#include +#include +#include + +CDelayBuffer::CDelayBuffer(const std::string& name, unsigned int blockSize, unsigned int blockTime, unsigned int jitterTime, bool debug) : +m_name(name), +m_blockSize(blockSize), +m_blockTime(blockTime), +m_debug(debug), +m_timer(1000U, 0U, jitterTime), +m_stopWatch(), +m_running(false), +m_buffer(5000U, name.c_str()), +m_outputCount(0U), +m_lastData(NULL), +m_lastDataLength(0U), +m_lastDataValid(false) +{ + assert(blockSize > 0U); + assert(blockTime > 0U); + assert(jitterTime > 0U); + + m_lastData = new unsigned char[m_blockSize]; + + reset(); +} + +CDelayBuffer::~CDelayBuffer() +{ + delete[] m_lastData; +} + +bool CDelayBuffer::addData(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + assert(length == m_blockSize); + + if (m_debug) + LogDebug("%s, DelayBuffer: appending data", m_name.c_str()); + + m_buffer.addData(data, length); + + if (!m_timer.isRunning()) { + if (m_debug) + LogDebug("%s, DelayBuffer: starting the timer from append", m_name.c_str()); + m_timer.start(); + } + + return true; +} + +B_STATUS CDelayBuffer::getData(unsigned char* data, unsigned int& length) +{ + assert(data != NULL); + + if (!m_running) + return BS_NO_DATA; + + unsigned int needed = m_stopWatch.elapsed() / m_blockTime + 2U; + if (needed <= m_outputCount) + return BS_NO_DATA; + + if (!m_buffer.isEmpty()) { + if (m_debug) + LogDebug("%s, DelayBuffer: returning data, elapsed=%ums", m_name.c_str(), m_stopWatch.elapsed()); + + if (m_buffer.getData(data, m_blockSize)) { + length = m_blockSize; + + // Save this data in case no more data is available next time + ::memcpy(m_lastData, data, length); + m_lastDataLength = length; + m_lastDataValid = true; + + m_outputCount++; + + return BS_DATA; + } + } + + if (m_debug) + LogDebug("%s, DelayBuffer: no data available, elapsed=%ums", m_name.c_str(), m_stopWatch.elapsed()); + + // Return the last data frame if we have it + if (m_lastDataLength > 0U) { + if(m_lastDataValid) { + if (m_debug) + LogDebug("%s, DelayBuffer: returning the last received frame", m_name.c_str()); + // Copy last valid data + ::memcpy(data, m_lastData, m_lastDataLength); + } else { + if (m_debug) + LogDebug("%s, DelayBuffer: returning a silence frame", m_name.c_str()); + // Copy last network header data + ::memcpy(data, m_lastData, 20U); + // We only need to copy silence AMBE data, don't care about LC data for next YSF conversion stage + ::memcpy(data + 20U, DMR_SILENCE_DATA, 33U); + data[53U] = 0U; + data[54U] = 0U; + } + + m_lastDataValid = false; + length = m_lastDataLength; + + m_outputCount++; + + return BS_MISSING; + } + + return BS_NO_DATA; +} + +void CDelayBuffer::reset() +{ + m_buffer.clear(); + + m_lastDataLength = 0U; + + m_outputCount = 0U; + + m_timer.stop(); + + m_running = false; +} + +void CDelayBuffer::clock(unsigned int ms) +{ + m_timer.clock(ms); + if (m_timer.isRunning() && m_timer.hasExpired()) { + if (!m_running) { + m_stopWatch.start(); + m_running = true; + } + } +} diff --git a/DMR2M17/DelayBuffer.h b/DMR2M17/DelayBuffer.h new file mode 100644 index 0000000..779975f --- /dev/null +++ b/DMR2M17/DelayBuffer.h @@ -0,0 +1,58 @@ +/* +* Copyright (C) 2018 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(DELAYBUFFER_H) +#define DELAYBUFFER_H + +#include "RingBuffer.h" +#include "StopWatch.h" +#include "Defines.h" +#include "Timer.h" + +#include + +class CDelayBuffer { +public: + CDelayBuffer(const std::string& name, unsigned int blockSize, unsigned int blockTime, unsigned int jitterTime, bool debug); + ~CDelayBuffer(); + + bool addData(const unsigned char* data, unsigned int length); + + B_STATUS getData(unsigned char* data, unsigned int& length); + + void reset(); + + void clock(unsigned int ms); + +private: + std::string m_name; + unsigned int m_blockSize; + unsigned int m_blockTime; + bool m_debug; + CTimer m_timer; + CStopWatch m_stopWatch; + bool m_running; + CRingBuffer m_buffer; + unsigned int m_outputCount; + + unsigned char* m_lastData; + unsigned int m_lastDataLength; + bool m_lastDataValid; +}; + +#endif diff --git a/DMR2M17/Golay2087.cpp b/DMR2M17/Golay2087.cpp new file mode 100644 index 0000000..61942d8 --- /dev/null +++ b/DMR2M17/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/DMR2M17/Golay2087.h b/DMR2M17/Golay2087.h new file mode 100644 index 0000000..d54daed --- /dev/null +++ b/DMR2M17/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/DMR2M17/Golay24128.cpp b/DMR2M17/Golay24128.cpp new file mode 100644 index 0000000..417da00 --- /dev/null +++ b/DMR2M17/Golay24128.cpp @@ -0,0 +1,1108 @@ +/* + * Copyright (C) 2010,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2002 by Robert H. Morelos-Zaragoza. All rights reserved. + */ + +#include "Golay24128.h" + +#include +#include + +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); +} + +unsigned int CGolay24128::decode24128(unsigned char* bytes) +{ + assert(bytes != NULL); + + unsigned int code = bytes[0U]; + code <<= 8; + code |= bytes[1U]; + code <<= 8; + code |= bytes[2U]; + + return decode23127(code >> 1); +} diff --git a/DMR2M17/Golay24128.h b/DMR2M17/Golay24128.h new file mode 100644 index 0000000..1ac7852 --- /dev/null +++ b/DMR2M17/Golay24128.h @@ -0,0 +1,32 @@ +/* + * 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); + static unsigned int decode24128(unsigned char* bytes); +}; + +#endif diff --git a/DMR2M17/Hamming.cpp b/DMR2M17/Hamming.cpp new file mode 100644 index 0000000..166e012 --- /dev/null +++ b/DMR2M17/Hamming.cpp @@ -0,0 +1,349 @@ +/* + * 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 "Hamming.h" + +#include +#include + + // Hamming (15,11,3) check a boolean data array +bool CHamming::decode15113_1(bool* d) +{ + assert(d != NULL); + + // Calculate the parity it should have + bool c0 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[6]; + bool c1 = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[7] ^ d[8] ^ d[9]; + bool c2 = d[0] ^ d[1] ^ d[4] ^ d[5] ^ d[7] ^ d[8] ^ d[10]; + bool c3 = d[0] ^ d[2] ^ d[4] ^ d[6] ^ d[7] ^ d[9] ^ d[10]; + + unsigned char n = 0U; + 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 0x0FU: d[0] = !d[0]; return true; + case 0x07U: d[1] = !d[1]; return true; + case 0x0BU: d[2] = !d[2]; return true; + case 0x03U: d[3] = !d[3]; return true; + case 0x0DU: d[4] = !d[4]; return true; + case 0x05U: d[5] = !d[5]; return true; + case 0x09U: d[6] = !d[6]; return true; + case 0x0EU: d[7] = !d[7]; return true; + case 0x06U: d[8] = !d[8]; return true; + case 0x0AU: d[9] = !d[9]; return true; + case 0x0CU: d[10] = !d[10]; return true; + + // No bit errors + default: return false; + } +} + +void CHamming::encode15113_1(bool* d) +{ + assert(d != NULL); + + // Calculate the checksum this row should have + d[11] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[4] ^ d[5] ^ d[6]; + d[12] = d[0] ^ d[1] ^ d[2] ^ d[3] ^ d[7] ^ d[8] ^ d[9]; + d[13] = d[0] ^ d[1] ^ d[4] ^ d[5] ^ d[7] ^ d[8] ^ d[10]; + d[14] = d[0] ^ d[2] ^ d[4] ^ d[6] ^ d[7] ^ d[9] ^ d[10]; +} + +// Hamming (15,11,3) check a boolean data array +bool CHamming::decode15113_2(bool* d) +{ + assert(d != NULL); + + // 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_2(bool* d) +{ + assert(d != NULL); + + // 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) +{ + assert(d != NULL); + + // 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) +{ + assert(d != NULL); + + // 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]; +} + +// Hamming (10,6,3) check a boolean data array +bool CHamming::decode1063(bool* d) +{ + assert(d != NULL); + + // Calculate the checksum this column should have + bool c0 = d[0] ^ d[1] ^ d[2] ^ d[5]; + bool c1 = d[0] ^ d[1] ^ d[3] ^ d[5]; + bool c2 = d[0] ^ d[2] ^ d[3] ^ d[4]; + bool c3 = d[1] ^ d[2] ^ d[3] ^ d[4]; + + unsigned char n = 0x00U; + n |= (c0 != d[6]) ? 0x01U : 0x00U; + n |= (c1 != d[7]) ? 0x02U : 0x00U; + n |= (c2 != d[8]) ? 0x04U : 0x00U; + n |= (c3 != d[9]) ? 0x08U : 0x00U; + + switch (n) { + // Parity bit errors + case 0x01U: d[6] = !d[6]; return true; + case 0x02U: d[7] = !d[7]; return true; + case 0x04U: d[8] = !d[8]; return true; + case 0x08U: d[9] = !d[9]; return true; + + // Data bit erros + case 0x07U: d[0] = !d[0]; return true; + case 0x0BU: d[1] = !d[1]; return true; + case 0x0DU: d[2] = !d[2]; return true; + case 0x0EU: d[3] = !d[3]; return true; + case 0x0CU: d[4] = !d[4]; return true; + case 0x03U: d[5] = !d[5]; return true; + + // No bit errors + default: return false; + } +} + +void CHamming::encode1063(bool* d) +{ + assert(d != NULL); + + // Calculate the checksum this column should have + d[6] = d[0] ^ d[1] ^ d[2] ^ d[5]; + d[7] = d[0] ^ d[1] ^ d[3] ^ d[5]; + d[8] = d[0] ^ d[2] ^ d[3] ^ d[4]; + d[9] = d[1] ^ d[2] ^ d[3] ^ d[4]; +} + +// A Hamming (16,11,4) Check +bool CHamming::decode16114(bool* d) +{ + assert(d != NULL); + + // 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) +{ + assert(d != NULL); + + 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) +{ + assert(d != NULL); + + // 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) +{ + assert(d != NULL); + + 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/DMR2M17/Hamming.h b/DMR2M17/Hamming.h new file mode 100644 index 0000000..393e005 --- /dev/null +++ b/DMR2M17/Hamming.h @@ -0,0 +1,43 @@ +/* + * 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. + */ + +#ifndef Hamming_H +#define Hamming_H + +class CHamming { +public: + static void encode15113_1(bool* d); + static bool decode15113_1(bool* d); + + static void encode15113_2(bool* d); + static bool decode15113_2(bool* d); + + static void encode1393(bool* d); + static bool decode1393(bool* d); + + static void encode1063(bool* d); + static bool decode1063(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/DMR2M17/LICENSE b/DMR2M17/LICENSE new file mode 100644 index 0000000..3912109 --- /dev/null +++ b/DMR2M17/LICENSE @@ -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/DMR2M17/Log.cpp b/DMR2M17/Log.cpp new file mode 100644 index 0000000..fc37ebf --- /dev/null +++ b/DMR2M17/Log.cpp @@ -0,0 +1,136 @@ +/* + * 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 "Log.h" + +#if defined(_WIN32) || defined(_WIN64) +#include +#else +#include +#endif + +#include +#include +#include +#include +#include +#include + +static unsigned int m_fileLevel = 2U; +static std::string m_filePath; +static std::string m_fileRoot; + +static FILE* m_fpLog = NULL; + +static unsigned int m_displayLevel = 2U; + +static struct tm m_tm; + +static char LEVELS[] = " DMIWEF"; + +static bool LogOpen() +{ + if (m_fileLevel == 0U) + return true; + + 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[100U]; +#if defined(_WIN32) || defined(_WIN64) + ::sprintf(filename, "%s\\%s-%04d-%02d-%02d.log", m_filePath.c_str(), m_fileRoot.c_str(), tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday); +#else + ::sprintf(filename, "%s/%s-%04d-%02d-%02d.log", m_filePath.c_str(), m_fileRoot.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& filePath, const std::string& fileRoot, unsigned int fileLevel, unsigned int displayLevel) +{ + m_filePath = filePath; + m_fileRoot = fileRoot; + m_fileLevel = fileLevel; + m_displayLevel = displayLevel; + return ::LogOpen(); +} + +void LogFinalise() +{ + if (m_fpLog != NULL) + ::fclose(m_fpLog); +} + +void Log(unsigned int level, const char* fmt, ...) +{ + assert(fmt != NULL); + + char buffer[300U]; +#if defined(_WIN32) || defined(_WIN64) + SYSTEMTIME st; + ::GetSystemTime(&st); + + ::sprintf(buffer, "%c: %04u-%02u-%02u %02u:%02u:%02u.%03u ", LEVELS[level], st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds); +#else + struct timeval now; + ::gettimeofday(&now, NULL); + + struct tm* tm = ::gmtime(&now.tv_sec); + + ::sprintf(buffer, "%c: %04d-%02d-%02d %02d:%02d:%02d.%03lu ", LEVELS[level], tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, now.tv_usec / 1000U); +#endif + + va_list vl; + va_start(vl, fmt); + + ::vsprintf(buffer + ::strlen(buffer), fmt, vl); + + va_end(vl); + + if (level >= m_fileLevel && m_fileLevel != 0U) { + bool ret = ::LogOpen(); + if (!ret) + return; + + ::fprintf(m_fpLog, "%s\n", buffer); + ::fflush(m_fpLog); + } + + if (level >= m_displayLevel && m_displayLevel != 0U) { + ::fprintf(stdout, "%s\n", buffer); + ::fflush(stdout); + } + + if (level == 6U) { // Fatal + ::fclose(m_fpLog); + exit(1); + } +} diff --git a/DMR2M17/Log.h b/DMR2M17/Log.h new file mode 100644 index 0000000..d671ef9 --- /dev/null +++ b/DMR2M17/Log.h @@ -0,0 +1,36 @@ +/* + * 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(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& filePath, const std::string& fileRoot, unsigned int fileLevel, unsigned int displayLevel); +extern void LogFinalise(); + +#endif diff --git a/DMR2M17/M17Network.cpp b/DMR2M17/M17Network.cpp new file mode 100644 index 0000000..964c691 --- /dev/null +++ b/DMR2M17/M17Network.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2009-2014,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 "M17Network.h" +#include "Utils.h" +#include "Log.h" + +#include +#include +#include + + +CM17Network::CM17Network(const std::string& localAddress, unsigned int localPort, const std::string& gatewayAddress, unsigned int gatewayPort, unsigned char* callsign, bool debug) : +m_address(), +m_port(gatewayPort), +//m_socket(localAddress, localPort), +m_socket(localPort), +m_debug(debug) +{ + memcpy(m_callsign, callsign, 6); + m_address = CUDPSocket::lookup(gatewayAddress); +} + +CM17Network::~CM17Network() +{ +} + +bool CM17Network::open() +{ + LogInfo("Opening M17 network connection"); + + return m_socket.open(); +} + +bool CM17Network::writeData(const unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + if (m_debug) + CUtils::dump(1U, "M17 Network Data Sent", data, length); + + return m_socket.write(data, length, m_address, m_port); +} + +bool CM17Network::writePoll() +{ + unsigned char data[10U]; + + memcpy(data, "PONG", 4); + memcpy(data+4, m_callsign, 6); + + if (m_debug) + CUtils::dump(1U, "M17 Network Pong Sent", data, 10U); + + return m_socket.write(data, 10U, m_address, m_port); +} + +bool CM17Network::writeLink() +{ + unsigned char data[11U]; + + memcpy(data, "CONN", 4); + memcpy(data+4, m_callsign, 6); + data[10U] = 'A'; + if (m_debug) + CUtils::dump(1U, "M17 Network Link Sent", data, 11U); + + LogInfo("writeLink add:port == %x, %x", m_address.s_addr, m_port); + return m_socket.write(data, 11U, m_address, m_port); +} + +bool CM17Network::writeUnlink() +{ + unsigned char data[10U]; + + memcpy(data, "DISC", 4); + memcpy(data+4, m_callsign, 6); + + if (m_debug) + CUtils::dump(1U, "M17 Network Unlink Sent", data, 10U); + + return m_socket.write(data, 10U, m_address, m_port); +} + +unsigned int CM17Network::readData(unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + in_addr address; + unsigned int port; + int len = m_socket.read(data, length, address, port); + if (len <= 0) + return 0U; + + // Check if the data is for us + if (m_address.s_addr != address.s_addr || port != m_port) { + LogMessage("M17 packet received from an invalid source, %08X != %08X and/or %u != %u", m_address.s_addr, address.s_addr, m_port, port); + return 0U; + } + + if (m_debug) + CUtils::dump(1U, "M17 Network Data Received", data, len); + + return len; +} + +void CM17Network::close() +{ + m_socket.close(); + + LogInfo("Closing P25 network connection"); +} diff --git a/DMR2M17/M17Network.h b/DMR2M17/M17Network.h new file mode 100644 index 0000000..cd23837 --- /dev/null +++ b/DMR2M17/M17Network.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2009-2014,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 M17Network_H +#define M17Network_H + +#include "UDPSocket.h" + +#include +#include + +class CM17Network { +public: + CM17Network(const std::string& localAddress, unsigned int localPort, const std::string& gatewayAddress, unsigned int gatewayPort, unsigned char* callsign, bool debug); + ~CM17Network(); + + bool open(); + bool writeData(const unsigned char* data, unsigned int length); + unsigned int readData(unsigned char* data, unsigned int length); + bool writePoll(); + bool writeLink(); + bool writeUnlink(); + void close(); +private: + in_addr m_address; + unsigned int m_port; + CUDPSocket m_socket; + bool m_debug; + unsigned char m_callsign[6]; +}; + +#endif diff --git a/DMR2M17/MBEVocoder.cpp b/DMR2M17/MBEVocoder.cpp new file mode 100644 index 0000000..56ec99b --- /dev/null +++ b/DMR2M17/MBEVocoder.cpp @@ -0,0 +1,41 @@ +/* +* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* Copyright (C) 2020 by Doug McLain AD8DP +* +* 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 +#include +#include "MBEVocoder.h" + + +const uint8_t BIT_MASK_TABLE8[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U }; +#define WRITE_BIT8(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE8[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE8[(i)&7]) +#define READ_BIT8(p,i) (p[(i)>>3] & BIT_MASK_TABLE8[(i)&7]) + +MBEVocoder::MBEVocoder(void) +{ +} + +void MBEVocoder::decode_2450(int16_t *pcm, uint8_t *ambe49) +{ + md380_decode(ambe49, pcm); +} + +void MBEVocoder::encode_2450(int16_t *pcm, uint8_t *ambe49) +{ + md380_encode(ambe49, pcm); +} diff --git a/DMR2M17/MBEVocoder.h b/DMR2M17/MBEVocoder.h new file mode 100644 index 0000000..178f51a --- /dev/null +++ b/DMR2M17/MBEVocoder.h @@ -0,0 +1,35 @@ +/* +* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* Copyright (C) 2020 by Doug McLain AD8DP +* +* 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 INCLUDED_AMBE_ENCODER_H +#define INCLUDED_AMBE_ENCODER_H + +#include + +class MBEVocoder { +public: + void decode_2450(int16_t *, uint8_t *); + void encode_2450(int16_t *, uint8_t *); + MBEVocoder(void); + +private: +}; + +#endif /* INCLUDED_AMBE_ENCODER_H */ diff --git a/DMR2M17/MMDVMNetwork.cpp b/DMR2M17/MMDVMNetwork.cpp new file mode 100644 index 0000000..8ae8318 --- /dev/null +++ b/DMR2M17/MMDVMNetwork.cpp @@ -0,0 +1,342 @@ +/* + * Copyright (C) 2015,2016,2017 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 "MMDVMNetwork.h" + +#include "StopWatch.h" +#include "SHA256.h" +#include "Utils.h" +#include "Log.h" + +#include +#include + +const unsigned int BUFFER_LENGTH = 500U; + +const unsigned int HOMEBREW_DATA_PACKET_LENGTH = 55U; + + +CMMDVMNetwork::CMMDVMNetwork(const std::string& rptAddress, unsigned int rptPort, const std::string& localAddress, unsigned int localPort, bool debug) : +m_rptAddress(), +m_rptPort(rptPort), +m_id(0U), +m_netId(NULL), +m_debug(debug), +m_socket(localAddress, localPort), +m_buffer(NULL), +m_rxData(1000U, "MMDVM Network"), +m_options(), +m_configData(NULL), +m_configLen(0U), +m_positionData(NULL), +m_positionLen(0U), +m_talkerAliasData(NULL), +m_talkerAliasLen(0U) +{ + assert(!rptAddress.empty()); + assert(rptPort > 0U); + + m_rptAddress = CUDPSocket::lookup(rptAddress); + + m_buffer = new unsigned char[BUFFER_LENGTH]; + m_netId = new unsigned char[4U]; + + m_positionData = new unsigned char[50U]; + m_talkerAliasData = new unsigned char[50U]; + + CStopWatch stopWatch; + ::srand(stopWatch.start()); +} + +CMMDVMNetwork::~CMMDVMNetwork() +{ + delete[] m_netId; + delete[] m_buffer; + delete[] m_configData; + delete[] m_positionData; + delete[] m_talkerAliasData; +} + +std::string CMMDVMNetwork::getOptions() const +{ + return m_options; +} + +unsigned int CMMDVMNetwork::getConfig(unsigned char* config) const +{ + if (m_configData == 0U) + return 0U; + + ::memcpy(config, m_configData, m_configLen); + + return m_configLen; +} + +unsigned int CMMDVMNetwork::getId() const +{ + return m_id; +} + +bool CMMDVMNetwork::open() +{ + LogMessage("MMDVM Network, Opening"); + + return m_socket.open(); +} + +bool CMMDVMNetwork::read(CDMRData& data) +{ + 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; + + unsigned int streamId; + ::memcpy(&streamId, m_buffer + 16U, 4U); + + unsigned char ber = m_buffer[53U]; + + unsigned char rssi = m_buffer[54U]; + + data.setSeqNo(seqNo); + data.setSlotNo(slotNo); + data.setSrcId(srcId); + data.setDstId(dstId); + data.setFLCO(flco); + data.setStreamId(streamId); + data.setBER(ber); + data.setRSSI(rssi); + + 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 CMMDVMNetwork::write(const CDMRData& data) +{ + 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_netId, 4U); + + unsigned int slotNo = data.getSlotNo(); + + buffer[15U] = slotNo == 1U ? 0x00U : 0x80U; + + FLCO flco = data.getFLCO(); + buffer[15U] |= flco == FLCO_GROUP ? 0x00U : 0x40U; + + unsigned char dataType = data.getDataType(); + if (dataType == DT_VOICE_SYNC) { + buffer[15U] |= 0x10U; + } else if (dataType == DT_VOICE) { + buffer[15U] |= data.getN(); + } else { + buffer[15U] |= (0x20U | dataType); + } + + buffer[4U] = data.getSeqNo(); + + unsigned int streamId = data.getStreamId(); + ::memcpy(buffer + 16U, &streamId, 4U); + + data.getData(buffer + 20U); + + buffer[53U] = data.getBER(); + + buffer[54U] = data.getRSSI(); + + if (m_debug) + CUtils::dump(1U, "Network Transmitted", buffer, HOMEBREW_DATA_PACKET_LENGTH); + + m_socket.write(buffer, HOMEBREW_DATA_PACKET_LENGTH, m_rptAddress, m_rptPort); + + return true; +} + +bool CMMDVMNetwork::readPosition(unsigned char* data, unsigned int& length) +{ + if (m_positionLen == 0U) + return false; + + ::memcpy(data, m_positionData, m_positionLen); + length = m_positionLen; + + m_positionLen = 0U; + + return true; +} + +bool CMMDVMNetwork::readTalkerAlias(unsigned char* data, unsigned int& length) +{ + if (m_talkerAliasLen == 0U) + return false; + + ::memcpy(data, m_talkerAliasData, m_talkerAliasLen); + length = m_talkerAliasLen; + + m_talkerAliasLen = 0U; + + return true; +} + +bool CMMDVMNetwork::writeBeacon() +{ + unsigned char buffer[20U]; + ::memcpy(buffer + 0U, "RPTSBKN", 7U); + ::memcpy(buffer + 7U, m_netId, 4U); + + return m_socket.write(buffer, 11U, m_rptAddress, m_rptPort); +} + +void CMMDVMNetwork::close() +{ + unsigned char buffer[HOMEBREW_DATA_PACKET_LENGTH]; + ::memset(buffer, 0x00U, HOMEBREW_DATA_PACKET_LENGTH); + + LogMessage("MMDVM Network, Closing"); + + ::memcpy(buffer + 0U, "MSTCL", 5U); + ::memcpy(buffer + 5U, m_netId, 4U); + + m_socket.write(buffer, HOMEBREW_DATA_PACKET_LENGTH, m_rptAddress, m_rptPort); + m_socket.close(); +} + +void CMMDVMNetwork::clock(unsigned int ms) +{ + in_addr address; + unsigned int port; + int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, port); + if (length < 0) { + LogError("MMDVM Network, Socket has failed, reopening"); + close(); + open(); + return; + } + + if (m_debug && length > 0) + CUtils::dump(1U, "Network Received", m_buffer, length); + + if (length > 0 && m_rptAddress.s_addr == address.s_addr && m_rptPort == port) { + if (::memcmp(m_buffer, "DMRD", 4U) == 0) { + //if (m_debug) + //CUtils::dump(1U, "Network Received", m_buffer, length); + + unsigned char len = length; + m_rxData.addData(&len, 1U); + m_rxData.addData(m_buffer, len); + } else if (::memcmp(m_buffer, "DMRG", 4U) == 0) { + ::memcpy(m_positionData, m_buffer, length); + m_positionLen = length; + } else if (::memcmp(m_buffer, "DMRA", 4U) == 0) { + ::memcpy(m_talkerAliasData, m_buffer, length); + m_talkerAliasLen = length; + } else if (::memcmp(m_buffer, "RPTL", 4U) == 0) { + m_id = (m_buffer[4U] << 24) | (m_buffer[5U] << 16) | (m_buffer[6U] << 8) | (m_buffer[7U] << 0); + ::memcpy(m_netId, m_buffer + 4U, 4U); + + unsigned char ack[10U]; + ::memcpy(ack + 0U, "RPTACK", 6U); + + uint32_t salt = 1U; + ::memcpy(ack + 6U, &salt, sizeof(uint32_t)); + + m_socket.write(ack, 10U, m_rptAddress, m_rptPort); + } else if (::memcmp(m_buffer, "RPTK", 4U) == 0) { + unsigned char ack[10U]; + ::memcpy(ack + 0U, "RPTACK", 6U); + ::memcpy(ack + 6U, m_netId, 4U); + m_socket.write(ack, 10U, m_rptAddress, m_rptPort); + } else if (::memcmp(m_buffer, "RPTCL", 5U) == 0) { + ::LogMessage("MMDVM Network, The connected MMDVM is closing down"); + } else if (::memcmp(m_buffer, "RPTC", 4U) == 0) { + m_configLen = length - 8U; + m_configData = new unsigned char[m_configLen]; + ::memcpy(m_configData, m_buffer + 8U, m_configLen); + + unsigned char ack[10U]; + ::memcpy(ack + 0U, "RPTACK", 6U); + ::memcpy(ack + 6U, m_netId, 4U); + m_socket.write(ack, 10U, m_rptAddress, m_rptPort); + } else if (::memcmp(m_buffer, "RPTO", 4U) == 0) { + m_options = std::string((char*)(m_buffer + 8U), length - 8U); + + unsigned char ack[10U]; + ::memcpy(ack + 0U, "RPTACK", 6U); + ::memcpy(ack + 6U, m_netId, 4U); + m_socket.write(ack, 10U, m_rptAddress, m_rptPort); + } else if (::memcmp(m_buffer, "RPTPING", 7U) == 0) { + unsigned char pong[11U]; + ::memcpy(pong + 0U, "MSTPONG", 7U); + ::memcpy(pong + 7U, m_netId, 4U); + m_socket.write(pong, 11U, m_rptAddress, m_rptPort); + } else { + CUtils::dump("Unknown packet from the master", m_buffer, length); + } + } +} diff --git a/DMR2M17/MMDVMNetwork.h b/DMR2M17/MMDVMNetwork.h new file mode 100644 index 0000000..2f3ec00 --- /dev/null +++ b/DMR2M17/MMDVMNetwork.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2015,2016,2017 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(MMDVMNetwork_H) +#define MMDVMNetwork_H + +#include "UDPSocket.h" +#include "Timer.h" +#include "RingBuffer.h" +#include "DMRData.h" + +#include +#include + +class CMMDVMNetwork +{ +public: + CMMDVMNetwork(const std::string& rptAddress, unsigned int rptPort, const std::string& localAddress, unsigned int localPort, bool debug); + ~CMMDVMNetwork(); + + std::string getOptions() const; + + unsigned int getConfig(unsigned char* config) const; + + unsigned int getId() const; + + bool open(); + + bool read(CDMRData& data); + + bool write(const CDMRData& data); + + bool readPosition(unsigned char* data, unsigned int& length); + + bool readTalkerAlias(unsigned char* data, unsigned int& length); + + bool writeBeacon(); + + void clock(unsigned int ms); + + void close(); + +private: + in_addr m_rptAddress; + unsigned int m_rptPort; + unsigned int m_id; + unsigned char* m_netId; + bool m_debug; + CUDPSocket m_socket; + unsigned char* m_buffer; + CRingBuffer m_rxData; + std::string m_options; + unsigned char* m_configData; + unsigned int m_configLen; + unsigned char* m_positionData; + unsigned int m_positionLen; + unsigned char* m_talkerAliasData; + unsigned int m_talkerAliasLen; +}; + +#endif diff --git a/DMR2M17/Makefile b/DMR2M17/Makefile new file mode 100644 index 0000000..2bd4777 --- /dev/null +++ b/DMR2M17/Makefile @@ -0,0 +1,26 @@ +CC ?= gcc +CXX ?= g++ +CFLAGS ?= -g -O3 -Wall -std=c++0x -pthread +LIBS = -lm -lpthread -lmd380_vocoder +LDFLAGS ?= -g + +OBJECTS = BPTC19696.o Conf.o CRC.o DelayBuffer.o DMRData.o DMREMB.o DMREmbeddedData.o \ + DMRFullLC.o DMRLC.o DMRLookup.o DMRSlotType.o MMDVMNetwork.o M17Network.o Golay2087.o \ + Golay24128.o Hamming.o Log.o ModeConv.o Mutex.o QR1676.o RS129.o SHA256.o StopWatch.o \ + Sync.o Thread.o Timer.o UDPSocket.o Utils.o MBEVocoder.o codec2/codebooks.o codec2/kiss_fft.o \ + codec2/lpc.o codec2/nlp.o codec2/pack.o codec2/qbase.o codec2/quantise.o codec2/codec2.o DMR2M17.o + +all: DMR2M17 + +DMR2M17: $(OBJECTS) + $(CXX) $(OBJECTS) $(CFLAGS) $(LIBS) -o DMR2M17 -Xlinker --section-start=.firmware=0x0800C000 -Xlinker --section-start=.sram=0x20000000 + +%.o: %.cpp + $(CXX) $(CFLAGS) -c -o $@ $< + +install: + install -m 755 DMR2M17 /usr/local/bin/ + +clean: + $(RM) DMR2M17 *.o *.d *.bak codec2/*.o *~ + diff --git a/DMR2M17/ModeConv.cpp b/DMR2M17/ModeConv.cpp new file mode 100644 index 0000000..d8585a5 --- /dev/null +++ b/DMR2M17/ModeConv.cpp @@ -0,0 +1,781 @@ +/* + * Copyright (C) 2010,2014,2016,2018 by Jonathan Naylor G4KLX + * Copyright (C) 2016 Mathias Weyland, HB9FRV + * Copyright (C) 2018 by Andy Uribe CA6JAU + * Copyright (C) 2020 by Doug McLain AD8DP + * + * 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 "ModeConv.h" +#include "Golay24128.h" +#include "Utils.h" +#include "Log.h" + +#include +#include +#include + +const unsigned char BIT_MASK_TABLE[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U }; + +#define WRITE_BIT(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7]) +#define READ_BIT(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) + +const unsigned int PRNG_TABLE[] = { + 0x42CC47U, 0x19D6FEU, 0x304729U, 0x6B2CD0U, 0x60BF47U, 0x39650EU, 0x7354F1U, 0xEACF60U, 0x819C9FU, 0xDE25CEU, + 0xD7B745U, 0x8CC8B8U, 0x8D592BU, 0xF71257U, 0xBCA084U, 0xA5B329U, 0xEE6AFAU, 0xF7D9A7U, 0xBCC21CU, 0x4712D9U, + 0x4F2922U, 0x14FA37U, 0x5D43ECU, 0x564115U, 0x299A92U, 0x20A9EBU, 0x7B707DU, 0x3BE3A4U, 0x20D95BU, 0x6B085AU, + 0x5233A5U, 0x99A474U, 0xC0EDCBU, 0xCB5F12U, 0x918455U, 0xF897ECU, 0xE32E3BU, 0xAA7CC2U, 0xB1E7C9U, 0xFC561DU, + 0xA70DE6U, 0x8DBE73U, 0xD4F608U, 0x57658DU, 0x0E5E56U, 0x458DABU, 0x7E15B8U, 0x376645U, 0x2DFD86U, 0x64EC3BU, + 0x3F1F60U, 0x3481B4U, 0x4DA00FU, 0x067BCEU, 0x1B68B1U, 0xD19328U, 0xCA03FFU, 0xA31856U, 0xF8EB81U, 0xF9F2F8U, + 0xA26067U, 0xA91BB6U, 0xF19A59U, 0x9A6148U, 0x8372B6U, 0xC8E86FU, 0x9399DCU, 0x1A0291U, 0x619142U, 0x6DE9FFU, + 0x367A2CU, 0x7D2511U, 0x6484DAU, 0x2F1F0FU, 0x1E6DB4U, 0x55F6E1U, 0x0EA70AU, 0x061C96U, 0xDD0E45U, 0xB4D738U, + 0xAF64ABU, 0xE47F42U, 0xFDBE9DU, 0xB684ACU, 0xFE5773U, 0xC1E4A2U, 0x8AFD0DU, 0x932ED4U, 0xD814E3U, 0x81853AU, + 0x225EECU, 0x7A6945U, 0x31A112U, 0x2AB2EBU, 0x630974U, 0x785AB5U, 0x11E3CEU, 0x4A715BU, 0x402AA0U, 0x199B7DU, + 0x16C05EU, 0x6F5283U, 0xA4FB10U, 0xBFA8ECU, 0xF633B7U, 0xEC4012U, 0xADD8C9U, 0xD6EB1CU, 0xDD3027U, 0x84A1FAU, + 0xCF9E19U, 0xD64C80U, 0xBC4557U, 0xA7B62EU, 0x6E2DA1U, 0x311F50U, 0x38C68EU, 0x63D5BFU, 0x486E60U, 0x10BFE1U, + 0x5BAD1EU, 0x4A4647U, 0x0157F0U, 0x7ACC29U, 0x73BEEAU, 0x2825D7U, 0xA0940CU, 0xFBCFF9U, 0xB05C62U, 0x892426U, + 0xC6B3DDU, 0xDF3840U, 0x9449B3U, 0xCED3BEU, 0xE7804DU, 0xBC3B90U, 0xF5AA0BU, 0xE6D17EU, 0x2D43B5U, 0x345A04U, + 0x5EA9DBU, 0x07A202U, 0x0C7134U, 0x45C9FDU, 0x5EDA0AU, 0x310193U, 0x6830C4U, 0x62AA3DU, 0x3B59B2U, 0xB04043U, + 0xEB975CU, 0x82BCADU, 0x912E62U, 0xD8F7FBU, 0x82C489U, 0x895F54U, 0xF00FE7U, 0xFBBC2AU, 0xA2E771U, 0xE956C4U, + 0xF6CD1FU, 0x3F8FEAU, 0x0534E1U, 0x4C653CU, 0x17FE8FU, 0x1C4C52U, 0x4515A1U, 0x2E86A9U, 0x3FBD56U, 0x756C87U, + 0x6ED218U, 0x279179U, 0x7C0AA6U, 0xD53B17U, 0x8EE0C8U, 0x85F291U, 0xD94B36U, 0x9298EFU, 0xAB8318U, 0xE07301U, + 0xBB68DFU, 0xB2CB7CU, 0xE910A5U, 0xE101D2U, 0x92BB4BU, 0x59E8B4U, 0x407175U, 0x0B026AU, 0x12989BU, 0x792944U, + 0x2376EDU, 0x2EF5BAU, 0x758663U, 0x7C1ED5U, 0x078D0CU, 0x4EF6ABU, 0x5567F2U, 0x9F7C29U, 0xC68E9CU, 0xC51747U, + 0xBC6422U, 0xB7EFB9U, 0xECFD44U, 0xA50497U, 0xAF178AU, 0xD68C69U, 0xD97DB5U, 0x82670EU, 0xCBB45BU, 0x508D90U, + 0x190A25U, 0x63F0FEU, 0x68E3C7U, 0x317A10U, 0x3A09D9U, 0x6B926EU, 0x004237U, 0x1B79C8U, 0x53EA59U, 0x48B3B7U, + 0x811166U, 0xDE4A79U, 0xF5F988U, 0xAC6057U, 0xE733FEU, 0xFF89ADU, 0xB49830U, 0x8F4BC3U, 0xC6F00EU, 0x9DA135U, + 0x942FE0U, 0xC71C3BU, 0x4DC78FU, 0x3476C4U, 0x7F6C39U, 0x66BFAAU, 0x298657U, 0x725504U, 0x5B4E89U, 0x01FE72U, + 0x0835A3U, 0x53269CU, 0x189D4DU, 0x01CDC2U, 0xEA763BU, 0xF3A56DU, 0xB0BCD4U, 0xE80F13U, 0xE355CAU, 0x98C47DU, + 0x91AB24U, 0xCE38DBU, 0x87A35AU, 0x9CD3A5U, 0xD648F4U, 0xAF7B6FU, 0x24A292U, 0x7D3011U, 0x764B6DU, 0x2DDABEU, + 0x44D123U, 0x5E22D8U, 0x1FB09DU, 0x04A926U, 0x4F5AF3U, 0x064128U, 0x3DB105U, 0x70AAD6U, 0xAA392FU, 0xA1C4B8U, + 0xF8C7C0U, 0xD35D0FU, 0x8A2E9EU, 0xC1B761U, 0xDA44F0U, 0x925E8FU, 0x89CF4EU, 0xE8B4D1U, 0xB32728U, 0xB8FE7FU, + 0x61DCC6U, 0x2A4701U, 0x1614D8U, 0x5DADE2U, 0x46BE37U, 0x0F44DCU, 0x54D549U, 0x5D8E32U, 0x263DAFU, 0x2C237CU, + 0x75E291U, 0xBE5982U, 0xA74A7FU, 0xC493A4U, 0xDFA131U, 0x967A5AU, 0xCCCB8EU, 0xC1D835U, 0x9A02ECU, 0xF331BBU, + 0xE8B812U, 0xA3EBC5U, 0xBA507CU, 0x7080ABU, 0x099BC2U, 0x02285DU, 0x59718CU, 0x50C273U, 0x0B1862U, 0x4A1F8CU, + 0x70A655U, 0x3BF5C2U, 0x666FBBU, 0x6DDE68U, 0x3485C5U, 0x9F161EU, 0xC46F4BU, 0x8CFDF0U, 0x97C625U, 0xDE058EU, + 0xC59CD3U, 0xAEAE20U, 0xF775BCU, 0xFC647FU, 0xBD9F02U, 0xE70C91U, 0xCC1468U, 0x11E7B7U, 0x1AFC36U, 0x435B49U, + 0x080398U, 0x139027U, 0x7B63FEU, 0x607AF9U, 0x29E900U, 0x7293D6U, 0x79026FU, 0x00D930U, 0x0BEAF1U, 0xD3614EU, + 0x90119FU, 0x8B8AE4U, 0xC61969U, 0xBD609AU, 0xB4F247U, 0xEFA954U, 0xE518A9U, 0xBC0362U, 0xD7D0D6U, 0xCE7E8DU, + 0x856F18U, 0x1C94E3U, 0x578726U, 0x0D5F1DU, 0x24ECC0U, 0x7FF713U, 0x3E26AAU, 0x251D6DU, 0x6A8F14U, 0x53648BU, + 0x19757AU, 0x40AEB4U, 0xCB9CA5U, 0x90055AU, 0x9956C3U, 0xE2ED34U, 0xAB3C7DU, 0xB126EAU, 0xFA9513U, 0xA3D2C8U, + 0x886BFDU, 0xD9F836U, 0xD2A2E3U, 0x8D1359U, 0x454804U, 0x5EDBF7U, 0x37637AU, 0x2C3089U, 0x67ABD4U, 0x3E8847U, + 0x3551BAU, 0x4D6331U, 0x46B8C4U, 0x1D299FU, 0x54120EU, 0x5FC0E1U, 0x86D93BU, 0xE56A0EU, 0xFBB1D5U, 0xB2B600U, + 0xA94EABU, 0xE05DF6U, 0x9BE605U, 0x90B798U, 0xC92C6BU, 0xC3DE66U, 0x9AC7BDU, 0xD15448U, 0x6A3FD3U, 0x23ADA3U, + 0x78346CU, 0x7147F5U, 0x2BDC02U, 0x0EAD5BU, 0x553FFCU, 0x1EA425U, 0x07D5F2U, 0x4C4ECBU, 0x554C14U, 0x3EB3F5U, + 0xE4A26AU, 0xED799BU, 0xB6CA85U, 0xFFD25CU, 0xC421BFU, 0x8F3A22U, 0x96AB51U, 0xDC518CU, 0x895217U, 0x8289F2U, + 0xF9B8A9U, 0xF0231CU, 0x2BF1C7U, 0x62C80AU, 0x781B39U, 0x1320E5U, 0x4AB156U, 0x41EB8FU, 0x1848E0U, 0x13D771U, + 0x4886AEU, 0x203C5FU, 0x3B6F40U, 0x76F6A1U, 0xE5457EU, 0xAE1EE7U, 0xD7AC10U, 0xDCB549U, 0x8476EFU, 0x8FC536U, + 0xD49DE9U, 0x9D0ED8U, 0xA63513U, 0xEFE4A6U, 0xB4DF7DU, 0x3E0D00U, 0x779693U, 0x4CA75EU, 0x0568ADU, 0x527BB0U, + 0x59C34BU, 0x00109FU, 0x0A0B14U, 0x73FA61U, 0x38E0BAU, 0x23530FU, 0x6A88D4U, 0xB199DDU, 0x98322AU, 0xC260F3U, + 0xCBF944U, 0x908A0DU, 0xDB11F2U, 0xC28163U, 0xADFABDU, 0xBC694CU, 0xF65243U, 0xAD83BAU, 0xA40D6DU, 0x5F7EF4U, + 0x16E787U, 0x0DF44AU, 0x460EF1U, 0x5E1F24U, 0x15CC3FU, 0x6C77CAU, 0x676401U, 0x3C9CBDU, 0x359FEEU, 0x6A0413U, + 0x02F590U, 0x91EE4DU, 0xDA3C3EU, 0xC305A3U, 0x889658U, 0xF14D99U, 0xFA7F86U, 0xA1E677U, 0xE981E8U, 0xF21A10U, + 0xBB4BD7U, 0x80F1CEU, 0xCB6239U, 0x123BE0U, 0x1D885FU, 0x45921EU, 0x6641E1U, 0x3DE870U, 0x74BBAFU, 0x6F00C6U, + 0x261055U, 0x7DCBA8U, 0x57787AU, 0x0E2167U, 0x05B28CU, 0xCC8819U, 0x975BE2U, 0xBC52B7U, 0xE5E52CU, 0xEB37C9U, + 0xB20E12U, 0xF9DD2FU, 0xE8C6FCU, 0x837701U, 0xD8AD82U, 0xD1BE5AU, 0x0B0525U, 0x0244B4U, 0x79FE5BU, 0x322DCAU, + 0x2B3495U, 0x60876CU, 0x79DCFBU, 0x334C12U, 0x4C7745U, 0x45A4DCU, 0x1E3F23U, 0x175FF2U, 0xC4C0D8U, 0xAFF30DU, + 0xB72AF6U, 0xFCB96BU, 0xA5C338U, 0xAE5295U, 0xF54946U, 0xDCBABBU, 0x87A1A8U, 0xCF2165U, 0xD4DA9EU, 0x9FC90BU, + 0x223070U, 0x6922A4U, 0x30B92FU, 0x3348D6U, 0x695B01U, 0x20C038U, 0x1BB2EFU, 0x523B06U, 0x49EC99U, 0x02D7C8U, + 0x5B4777U, 0x713CA6U, 0xA8AF49U, 0xA3B650U, 0xF84586U, 0xB5DF7FU, 0xAE8CF8U, 0xC72581U, 0x9D3652U, 0x9EEDCFU, + 0xC75D34U, 0xCC0671U, 0xB5B5CAU, 0xFEAC1FU, 0x677EA4U, 0x2DC5F9U, 0x26D63AU, 0x7F1F86U, 0x142855U, 0x0DF2A8U, + 0x42E3B3U, 0x195872U, 0x108B8DU, 0x6AB31CU, 0x632063U, 0x307BAAU, 0xFBC83DU, 0xE201C4U, 0xA91393U, 0x90A82AU, + 0xDAF9E4U, 0x816A55U, 0x88D00AU, 0xD383DBU, 0xFA3A64U, 0xA569A5U, 0xEEE2DEU, 0x76D243U, 0x3D0D90U, 0x649E6DU, + 0x47E76EU, 0x1C7491U, 0x156E49U, 0x4E9DDEU, 0x0604B7U, 0x3D3720U, 0x76FDD9U, 0x6FEC06U, 0x2417B7U, 0xFD04F8U, + 0xF29D29U, 0x886F92U, 0xC1744FU, 0xDAC73CU, 0x939EB1U, 0x880C63U, 0xEBE79EU, 0xB2F285U, 0xB86970U, 0xE11ABBU, + 0xEA822EU, 0x311155U, 0x586AC0U, 0x43F92BU, 0x0A81F6U, 0x5412C5U, 0x5D111CU, 0x26E8CBU, 0x2D7B63U, 0x74213CU, + 0x3F90CDU, 0x2E8B52U, 0x645883U, 0xDFE36CU, 0x96F375U, 0xDD0882U, 0xC40B1BU, 0x8FD6CCU, 0xB464A5U, 0xFC7F3EU, + 0xA7AECBU, 0xAA9511U, 0xF10634U, 0xBA5CEFU, 0x83ED32U, 0x483681U, 0x5015DCU, 0x138D3FU, 0x48DEA2U, 0x616571U, + 0x3AF40CU, 0x33AF97U, 0x681D72U, 0x2246E9U, 0x3BD7B9U, 0x506C46U, 0x0D2FDFU, 0x869338U, 0xDDC061U, 0xD45BD6U, + 0xAF6A0FU, 0xE7B8C0U, 0xFC2371U, 0xBF102EU, 0xA6C9DFU, 0xEDDA40U, 0x943089U, 0x9FA1BFU, 0x459A66U, 0x0C4995U, + 0x175108U, 0x7AE243U, 0x6139B6U, 0x2A2A2DU, 0x73D3D8U, 0x79C183U, 0x204A26U, 0x0B3FFDU, 0x5AA420U, 0x111613U, + 0x8A4FDFU, 0xC3DC2CU, 0xF9A7B5U, 0xB034EAU, 0xEBAC5BU, 0xE0CF94U, 0xBD5465U, 0xF605FAU, 0xCFBEA3U, 0x85AC54U, + 0x9E55DDU, 0xD7C62AU, 0x0CDD73U, 0x252FCDU, 0x76361CU, 0x7DF5D3U, 0x3546E2U, 0x6E5B39U, 0x67A98CU, 0x1CB247U, + 0x57231AU, 0x4AD8A9U, 0x01CA74U, 0x191187U, 0xF2208AU, 0xA9AB50U, 0xA0F8A5U, 0xFB403EU, 0xF2D34BU, 0xA9A880U, + 0xCB393DU, 0xD262EEU, 0x99D0B7U, 0xC04B00U, 0xCB1AC9U, 0xB0B176U, 0x39E3A7U, 0x677EF8U, 0x2ECD58U, 0x359687U, + 0x7E277EU, 0x473D69U, 0x0CEEB0U, 0x55D557U, 0x5F04CEU, 0x0C8EBDU, 0x25BD60U, 0x7E64DBU, 0xB7771EU, 0xACCC05U, + 0xE51CF0U, 0xBF2F2AU, 0x90F497U, 0xC9E7D4U, 0xC25F09U, 0x9B9CBAU, 0xD08767U, 0xEB320CU, 0xA36999U, 0x38FB42U, + 0x7180B3U, 0x22112CU, 0x29AA45U, 0x50F9D2U, 0x1B610AU, 0x0202FDU, 0x4899E4U, 0x57080BU, 0x3E72DAU, 0x65E165U, + 0x6CFA34U, 0xB70BEBU, 0xBC104AU, 0xE4E295U, 0x8F7BECU, 0x96787FU, 0xD583B2U, 0x9E9740U, 0x870C5DU, 0xECFFA6U, + 0xF4E433U, 0xBF35F8U, 0xE00F8DU, 0x699C16U, 0x3265EBU, 0x1B6638U, 0x40F515U, 0x0A8DC6U, 0x131E1BU, 0x5845A0U, + 0x21F670U, 0x2A6E1FU, 0x791D8EU, 0x708651U, 0x2AD7E8U, 0xE37CAFU, 0xD8EE56U, 0x97B3C1U, 0x8E0018U, 0xC51B6FU, + 0x9CC9E6U, 0xB67019U, 0xEF23C8U, 0xE498F2U, 0xBF9927U, 0xF643ECU, 0xCD7051U, 0x04E902U, 0x563AFFU, 0x5D006CU, + 0x04D3A1U, 0x0FCA9AU, 0x72794FU, 0x39A2B4U, 0x228231U, 0x6A19EAU, 0x714E96U, 0x18F705U, 0x4324FCU, 0xC83E3BU, + 0x918D02U, 0xDADCD5U, 0xC2470CU, 0xA135B3U, 0xBABCF2U, 0xF30F4DU, 0xA8549EU, 0xA1C543U, 0xDEFF78U, 0xD42CBCU, + 0x0DB747U, 0x46C6D2U, 0x5F5C89U, 0x144F60U, 0x6FA6F7U, 0x66350EU, 0x2C0A59U, 0x35DAE0U, 0x7EC12FU, 0x0D32FEU, + 0x0429C1U, 0x5FB911U, 0xD642AEU, 0x895167U, 0xC3D8B0U, 0xFAAB89U, 0xB1315AU, 0xA8C0A7U, 0xE3DB24U, 0xB84879U, + 0x913382U, 0xCBA317U, 0x82F8FCU, 0x994BA9U, 0x50C213U, 0x4390CEU, 0x282F5DU, 0x713E30U, 0x7FCDE3U, 0x26565EU, + 0x2D0485U, 0x56BDD4U, 0x1FAE7BU, 0x0475AAU, 0x4DD555U, 0x17CE4CU, 0x9C1D9BU, 0xE52473U, 0xEEF7E4U, 0xB7CD1DU, + 0xF45E42U, 0xEF87E3U, 0x87B43CU, 0x986FADU, 0xD16FD2U, 0x8AD403U, 0x8103A8U, 0xD83A75U, 0x33A826U, 0x2BF39BU, + 0x604049U, 0x7B99A4U, 0x328ABFU, 0x49306AU, 0x407191U, 0x1BEA04U, 0x19D96FU, 0x4001F2U, 0x0FB201U, 0x36E9DCU, + 0xFD7ADFU, 0xE64326U, 0xAF91F9U, 0xF51249U, 0xDC2B16U, 0x87F8D7U, 0xCCE668U, 0xC517B1U, 0x9E8C46U, 0x97BF5FU, + 0xED6498U, 0xA67461U, 0x378FF6U, 0x788C8FU, 0x611514U, 0x0AE6F1U, 0x53FC2BU, 0x596F3EU, 0x0216C5U, 0x4B8508U, + 0x507FBBU, 0x396EE6U, 0x22F535U, 0xE99688U, 0xB10F43U, 0xBA1D36U, 0xC3E2ADU, 0xC07178U, 0x9B28C3U, 0xD69A8BU, + 0xCD817CU, 0x8570E5U, 0xFEEB12U, 0xF5E8CBU, 0xAC10C4U, 0x270335U, 0x7ED8EAU, 0x156B5BU, 0x0E7A14U, 0x46A0C5U, + 0x5D937AU, 0x144AA3U, 0x4F79D5U, 0x6CF35CU, 0x31228FU, 0x7A1932U, 0x628E69U, 0xA9D59CU, 0x926517U, 0xDBBEE2U, + 0x80ADB9U, 0x891424U, 0xD246D7U, 0xD8ED1AU, 0xA17C28U, 0xEA27F5U, 0xF3942EU, 0xB8CE8FU, 0xAB5FD0U, 0x466461U, + 0x1CB7BEU, 0x152F6FU, 0x4E1CC0U, 0x05D799U, 0x1CE66EU, 0x773DF7U, 0x7EAB00U, 0x249048U, 0x6D41D7U, 0x765A26U, + 0x1DA9F9U, 0x8431C8U, 0xCF0203U, 0x96C1DEU, 0x90D86DU, 0xCB6A30U, 0xA23193U, 0xB9A24EU, 0xF05B95U, 0xEB48A0U, + 0xA0D27AU, 0xD8A39FU, 0xD33804U, 0x0A9B79U, 0x01C3AAU, 0x5A5437U, 0x132FD4U, 0x28BC0DU, 0x60253AU, 0x3F57E3U, + 0x3CCC7CU, 0x65DD9DU, 0x4E26C2U, 0x172572U, 0xDCDDADU, 0xC64E64U, 0x8F5553U, 0x94A68AU, 0xFDBE7DU, 0xA66DE4U, + 0xADD68BU, 0xF4C75AU, 0xFE0CC1U, 0x873E34U, 0xC8A72FU, 0xDBD0C2U, 0x124B10U, 0x49998DU, 0x40A8FEU, 0x3A3323U, + 0x316088U, 0x68D95DU, 0x235B06U, 0x3A00B3U, 0x51B178U, 0x4AEA89U, 0x025816U, 0x59C36FU, 0xD092B8U, 0x8B2930U, + 0xE43AC7U, 0xF5E2DEU, 0xBEC121U, 0xA71AF0U, 0xED8B7FU, 0x94B40EU, 0x9F66D1U, 0xD45D68U, 0xCD8CBFU, 0x8617F6U, + 0x5F2545U, 0x75FC98U, 0x2EFF62U, 0x674467U, 0x7C959CU, 0x318F09U, 0x0A7CD2U, 0x4967AFU, 0x11D62CU, 0x1A8CD1U, + 0x431F02U, 0x48A69DU, 0xB3E5ECU, 0xFA7623U, 0xE10E9AU, 0xA99948U, 0xB20215U, 0xD971A6U, 0x80E86BU, 0x8BDA90U, + 0xD60185U, 0x9D907EU, 0x8FFBFBU, 0xE66920U, 0x7D705DU, 0x3483CEU, 0x6F9833U, 0x646BF1U, 0x1DF3E8U, 0x17E017U, + 0x4E1BC6U, 0x050A79U, 0x1E8038U, 0x5773E7U, 0x2C685EU, 0xA1BD89U, 0xFB86B0U, 0xF01477U, 0xA16D8EU, 0xCAFE19U, + 0xD365C1U, 0x9815AEU, 0x839E3FU, 0xCBCDC4U, 0x907611U, 0xB9E70AU, 0xE2BDE7U, 0x2B0E34U, 0x301789U, 0x7BE4DAU, + 0x477707U, 0x0C2FACU, 0x558C79U, 0x5E9743U, 0x0D4496U, 0x04786DU, 0x7FABE0U, 0x3730B3U, 0x3C014AU, 0xE7DADDU, + 0xEEE834U, 0x956163U, 0xDCB2FAU, 0xC78905U, 0x8D5BD4U, 0xD0427BU, 0xDBF12BU, 0xA22AB4U, 0xA93B4DU, 0xFA819AU, + 0xB3D2B3U, 0x287B64U, 0x40289DU, 0x5BB206U, 0x100153U, 0x495CB8U, 0x42CF2DU, 0x3BF4D6U, 0x70248BU, 0x6ABF19U, + 0x23CCF4U, 0x3C4527U, 0x75761AU, 0x8EACC1U, 0x853F44U, 0xD44EBFU, 0xDED5EEU, 0x87C751U, 0xEC3E80U, 0xF72D6FU, + 0xBEB676U, 0xE557A1U, 0xEC4D59U, 0xB6BECEU, 0x9DA527U, 0x443078U, 0x0BCAE9U, 0x12D916U, 0x594087U, 0x6033E8U, + 0x22A831U, 0x7948A2U, 0x70535FU, 0x2BC01CU, 0x62BBA1U, 0x592A7BU, 0x92308EU, 0x8AC395U, 0xC15A50U, 0x9809ABU, + 0xB3B336U, 0xECB245U, 0xE54998U, 0xBEDA1BU, 0xF681E6U, 0xED35F5U, 0x8E2E0CU, 0x87FDD3U, 0x5CC453U, 0x1556ACU, + 0x0E85FDU, 0x64AC42U, 0x3D7F8BU, 0x36447CU, 0x6FD665U, 0x640FB2U, 0x3B3C4BU, 0x52A7C4U, 0x48F7B5U, 0x014C2EU, + 0x9A9FFBU, 0xD19601U, 0xA0250CU, 0xAB7FFFU, 0xF2C822U, 0xB8D1B1U, 0xA302CCU, 0xEAB907U, 0xD1E9B2U, 0x987269U, + 0xC3411CU, 0xCC8897U, 0x141A42U, 0x3F61B8U, 0x66F2A1U, 0x2DCB56U, 0x3618DFU, 0x778208U, 0x2CB3F1U, 0x0468EEU, + 0x5F7B1FU, 0x5693D0U, 0x0D8041U, 0x461B3EU, 0xFFECE7U, 0xB4FD50U, 0xA94798U, 0xE314CFU, 0xB88D76U, 0xB17EADU, + 0xCA7508U, 0xC3E553U, 0x989EA6U, 0xDB0D3DU, 0xC396E8U, 0xA8E683U, 0x717D1EU, 0x7A0EEDU, 0x219730U, 0x288422U, + 0x736ECFU, 0x1BFF14U, 0x04A4A1U, 0x4F177AU, 0x56092BU, 0x1DD884U, 0x64635DU, 0xEF70EAU, 0xA589B3U, 0xF49B54U, + 0xFF50CDU, 0xA66312U, 0x8DFA62U, 0xD628FDU, 0x9F131CU, 0x8582C3U, 0xCCF9DAU, 0xF36A29U, 0xB8B2F4U, 0x618157U, + 0x6A020AU, 0x335999U, 0x79E864U, 0x4272BFU, 0x03259AU, 0x189C40U, 0x51CFB5U, 0x0A752EU, 0x216463U, 0x79BF90U, + 0x721C0DU, 0xAB47FEU, 0xE4D727U, 0xFDEC28U, 0x963FD9U, 0x8DA646U, 0xC594B7U, 0x9E4FE8U, 0x977E60U, 0xECA597U, + 0xAF264EU, 0xB61C79U, 0xFDCDA0U, 0x65D64FU, 0x2E61DCU, 0x553881U, 0x5CAA72U, 0x0351FBU, 0x0A400CU, 0x51FB55U, + 0x3BB9CAU, 0x22223AU, 0x6993B5U, 0x30C8C4U, 0x3B5B1BU, 0xE02B82U, 0xC1B075U, 0x9B23BCU, 0xD25A8BU, 0xC9C852U, + 0x82A3A9U, 0xBB303CU, 0xF42977U, 0xADDA82U, 0xA64418U, 0xFC55E5U, 0xB5AEE6U, 0x0EBD3BU, 0x4765C8U, 0x4CD655U, + 0x17DD2EU, 0x562EEBU, 0x6C3770U, 0x25A585U, 0x3E5EDEU, 0x754F6FU, 0x2C94A1U, 0x23A758U, 0x5A3F4FU, 0xD07C96U, + 0x8BC761U, 0xC254E8U, 0xD92C97U, 0xB0BF06U, 0xEBE0D9U, 0xE25138U, 0xB8CAA7U, 0xBB98DEU, 0xE22109U, 0x896291U, + 0x10F172U, 0x5BCB2FU, 0x401A94U, 0x0CA141U, 0x77B2BAU, 0x7E6BBFU, 0x255964U, 0x6E82D9U, 0x77130AU, 0x3C3877U, + 0x04EAF4U, 0x4FD129U, 0x9C40DBU, 0x959BC6U, 0xCEAC2DU, 0xE774FCU, 0xBC6763U, 0xF6DC12U, 0xEB8DCDU, 0xA00664U, + 0xF9F4B3U, 0xD2EF4AU, 0x895E5DU, 0x800584U, 0x5A972BU, 0x132EFBU, 0x287D84U, 0x63E615U, 0x7297CEU, 0x391D23U, + 0x608E30U, 0x6AF5CDU, 0x11641EU, 0x5C5E93U, 0x4789E0U, 0x0E903DU, 0x956386U, 0xFEF053U, 0xB6E879U, 0xAD0BACU, + 0xE41077U, 0xFF83CAU, 0xB47A99U, 0xCD6870U, 0xCE93E7U, 0x96823EU, 0x9D1941U, 0xC4EBD0U, 0x2BF23FU, 0x3031EEU, + 0x790A71U, 0x229909U, 0x2AC1CEU, 0x717677U, 0x5AEDA0U, 0x039C99U, 0x480646U, 0x515587U, 0x1AEC3CU, 0x296F69U, + 0xE13492U, 0xBA8607U, 0xB39FCCU, 0xEC4CB1U, 0xA77723U, 0x9EA7DEU, 0xD51C0DU, 0xCD0F00U, 0x86D4FBU, 0xDDF56EU, + 0xF46F95U, 0x2FBCD4U, 0x268D6BU, 0x7D52B2U, 0x374165U, 0x26F9DCU, 0x4D2A9BU, 0x141163U, 0x1FD2FCU, 0x40CA2DU, + 0x497952U, 0x3322D3U, 0x7AB32CU, 0xE108F5U, 0xAA5AE2U, 0xB3E31BU, 0xF8B098U, 0x812B65U, 0x8B8936U, 0xD0D08AU, + 0xD94341U, 0x8A7894U, 0xE3A9AFU, 0xF8377AU, 0xB74481U, 0x6FDD0CU, 0x64EE5FU, 0x3D35A2U, 0x163731U, 0x5F8ECCU, + 0x045DC7U, 0x0F4616U, 0x57B6E8U, 0x7CAD79U, 0x253E86U, 0x6EC7CFU, 0x7DD478U, 0xB426A1U, 0xCF2D76U, 0xC3BC5FU, + 0x984780U, 0x935571U, 0xCACCEEU, 0x81BBBFU, 0xB82054U, 0xF371C0U, 0xE9CB3BU, 0xA05826U, 0xFB33F5U, 0x52A218U, + 0x09B88BU, 0x424BF6U, 0x53D22DU, 0x198198U, 0x043A53U, 0x6F2A06U, 0x34F1BDU, 0x3DC260U, 0x664982U, 0x6FB81BU, + 0x15A24CU, 0xDE71F5U, 0xC7482AU, 0x8CDFCBU, 0x9505D4U, 0xDE3405U, 0xA5EFFAU, 0xA4FC63U, 0xFE5704U, 0xB387DDU, + 0xA8BC6AU, 0xC32FB2U, 0x5A7EE5U, 0x11C44CU, 0x489797U, 0x420E62U, 0x19BD79U, 0x30E6BCU, 0x6B6407U, 0x225DDAU, + 0x398EA9U, 0x703534U, 0x0A64F7U, 0x09FA0AU, 0xD4C910U, 0xDF10E5U, 0x86833EU, 0xCDB99BU, 0xE67A40U, 0xBE631BU, + 0xB590AEU, 0xEC8B75U, 0xA73BD0U, 0x9CE08BU, 0xD5F35EU, 0x8E0AE5U, 0x061828U, 0x5D835AU, 0x5660C7U, 0x277914U, + 0x68CAE9U, 0x7190E2U, 0x3A0113U, 0x20FECCU, 0x49ED7DU, 0x127522U, 0x1B06ABU, 0x40855CU, 0x8B9E85U, 0x926FB2U, + 0xF8F56AU, 0xE186A5U, 0xAA1F14U, 0xF10CCBU, 0xF0F7BAU, 0x8F6735U, 0x867CECU, 0xDC9F1FU, 0x978402U, 0x8E54F1U, + 0x45EF3CU, 0x7CFC8FU, 0x3705D2U, 0x6C1248U, 0x64C8BDU, 0x3FF976U, 0x566243U, 0x4DA198U, 0x069B45U, 0x1F0AF6U, + 0x5851BBU, 0x00E248U, 0xAB3BD1U, 0xF2090EU, 0xF9926FU, 0xA2C3F1U, 0xEB7800U, 0xD07B9FU, 0x98A1E6U, 0xC31021U, + 0xC84BB8U, 0x91D84FU, 0x9AEC96U, 0x6337A9U, 0x288468U, 0x369FB3U, 0x774E06U, 0x6C645DU, 0x05B7A9U, 0x4E2E22U, + 0x551DFFU, 0x1CC78CU, 0x47D611U, 0x4F2DF2U, 0x343E6FU, 0xBF8514U, 0xE655C1U, 0xAD5E5AU, 0xB4EDBFU, 0xDFB4E4U, + 0xC1265DU, 0x80DD8BU, 0xDBC852U, 0xD25375U, 0x8920ACU, 0xA2BA53U, 0xFB0BC2U, 0x31401DU, 0x28D33CU, 0x63AAE3U, + 0x18381AU, 0x11238DU, 0x4AD2E4U, 0x434933U, 0x195BABU, 0x56A058U, 0x6FB105U, 0x2C5AAEU, 0x35C97BU, 0xFED9A0U, + 0xA52295U, 0x8D314EU, 0xD6ECA3U, 0x9F5E30U, 0x84456DU, 0xCFB6DEU, 0xD6AF03U, 0xBD2CE9U, 0xE556FCU, 0xEEC707U, + 0xB71CD6U, 0x382F59U, 0x43B720U, 0x02E4F7U, 0x195F4EU, 0x51CC99U, 0x0AA550U, 0x013767U, 0x786CBEU, 0x73DD01U, + 0x2AC6D1U, 0x61159EU, 0x7BA92FU, 0x92BAF4U, 0x896109U, 0xC0521AU, 0x9F9AF7U, 0x942924U, 0xC532B9U, 0xEFE3C2U, + 0xA6D807U, 0xFD0ABCU, 0xF69369U, 0xAFA033U, 0x44738EU, 0x5D694DU, 0x17C8F0U, 0x0C93A3U, 0x45207AU, 0x1EF9C5U, + 0x37EB04U, 0x6850FBU, 0x6305EAU, 0x3B9E15U, 0x782DC4U, 0x41774BU, 0x8AF633U, 0xD18DE4U, 0xD81E5DU, 0x83A69AU, + 0x8AF583U, 0xF06E7CU, 0xBB5FADU, 0xA28416U, 0xE99653U, 0xF06D88U, 0x9FEC35U, 0xC4F7E6U, 0x4C059AU, 0x1F1C19U, + 0x56EFC4U, 0x4D743FU, 0x24612AU, 0x3F9BD1U, 0x748814U, 0x2C13AFU, 0x27F276U, 0x5EE861U, 0x553B88U, 0x0E0A5FU, + 0xC791E6U, 0xD8E2B0U, 0x907A69U, 0xABE9C6U, 0xE09217U, 0xB10168U, 0xBA48F9U, 0xE3FA26U, 0x8861CFU, 0x9230D8U, + 0xDB8B21U, 0xC099B2U, 0x09644FU, 0x52F704U, 0x79AC90U, 0x201F6BU, 0x2E17BEU, 0x77C495U, 0x3CFF48U, 0x172E9BU, + 0x4E9426U, 0x0D8775U, 0x145E98U, 0x5E6D03U, 0xC5F6D6U, 0xAC242DU, 0xF70D3CU, 0xFEDED2U, 0xA5C543U, 0xAE74BCU, + 0xD62EE5U, 0x9D9D72U, 0x80029BU, 0xCB534CU, 0x90E175U, 0x19BAAAU, 0x6A3B6BU, 0x6280D4U, 0x39D385U, 0x724B7AU, + 0x6B78E2U, 0x00A321U, 0x19101CU, 0x5248CFU, 0x0ADB30U, 0x01F0A9U, 0x5A21CEU, 0xB73A17U, 0xACC880U, 0xE55179U, + 0xFE42A6U, 0xB4B987U, 0xC5AF58U, 0xCE1688U, 0x97C533U, 0x9CCE76U, 0xC73F8DU, 0x8E2510U, 0xB4B6C3U, 0x7D4FFEU, + 0x665C3DU, 0x2DC7C0U, 0x70B55BU, 0x5B2C2EU, 0x025FF5U, 0x49D470U, 0x53448AU, 0x1A3FD7U, 0x09AC64U, 0x60BDBDU, + 0x3B467AU, 0xB0D043U, 0xE98B9CU, 0xE33A2DU, 0x9A21E2U, 0xD1C3B3U, 0xCA5A0CU, 0x8709DDU, 0xDCB222U, 0xF5A3AAU, + 0xBF79DDU, 0xA44A04U, 0xEDD193U, 0x3E006AU, 0x373B21U, 0x4CF994U, 0x47C04FU, 0x1F53DAU, 0x5488A1U, 0x4DB86CU, + 0x2623DFU, 0x7D7402U, 0x70CF50U, 0x2B9EFDU, 0x232426U, 0xF8A7D3U, 0x91FEC8U, 0x8A4D39U, 0xC117F6U, 0xD0866FU, + 0x9B3D18U, 0xE36EC1U, 0xE8F576U, 0xB3C5BFU, 0xBA1629U, 0xE1BD50U, 0xA8EC8FU, 0x17763EU, 0x5D45F1U, 0x049CA0U, + 0x0F8F1FU, 0x5630C6U, 0x7DE225U, 0x26FB38U, 0x6F08CBU, 0x7D0316U, 0x34B28DU, 0x2F68E9U, 0xC47B72U, 0x9DC287U, + 0x96915CU, 0xCF0B41U, 0x85F8A2U, 0xBAE17FU, 0xF372CCU, 0xE81991U, 0xA1894AU, 0xFAF2EBU, 0xF16134U, 0x89F845U, + 0x0A8ADBU, 0x53153AU, 0x1806E5U, 0x03FF7CU, 0x6A7C0BU, 0x312692U, 0x399775U, 0x628CACU, 0x6D7FB3U, 0x34EE42U, + 0x5FF49DU, 0x56073CU, 0x8D1C67U, 0x87CDBBU, 0xDEE708U, 0xB574D5U, 0xA4ADB6U, 0xEF9E2BU, 0xF605D0U, 0xBD7545U, + 0xE6EE0EU, 0xCE39FBU, 0x950260U, 0xD8929DU, 0x43D9CEU, 0x086A47U, 0x31B3B1U, 0x7AA068U, 0x221ADFU, 0x294B86U, + 0x72F049U, 0x73E3F8U, 0x083927U, 0x418856U, 0x5AC3C9U, 0x105020U, 0xC969B7U, 0xE2BBEEU, 0xBF2019U, 0xB41181U, + 0xEFCA6AU, 0xA6FD3FU, 0xBC27A4U, 0xD53651U, 0xCE9D9AU, 0x854EA7U, 0xDC5E74U, 0xDFE5A9U, 0x26B61AU, 0x6C0D57U, + 0x77DCECU, 0x3EC639U, 0x2575C3U, 0x682CD6U, 0x13AF1DU, 0x1855ECU, 0x404473U, 0x4BDF8AU, 0x12ACDDU, 0xF93754U, + 0xE207A3U, 0xABD87AU, 0xF04B45U, 0xF03284U, 0xABB05BU, 0x80ABEBU, 0xD95AB4U, 0x92C10DU, 0x8FD2CEU, 0xC42833U, + 0xEC3920U, 0x37C2FDU, 0x7C5106U, 0x654883U, 0x2EAAF8U, 0x37B12DU, 0x5C20B6U, 0x065B42U, 0x07C909U, 0x5C12B4U, + 0x152367U, 0x2EB4FAU, 0x65CF19U, 0xFC5F40U, 0xB294FFU, 0xEBA72EU, 0xE03ED1U, 0x9B6CD0U, 0x92D70FU, 0xC944F6U, + 0x801D60U, 0x9AAE19U, 0xF1F4DEU, 0xA85547U, 0xAB4EB8U, 0x729DE9U, 0x792456U, 0x223697U, 0x4BED0CU, 0x55DE71U, + 0x1C03A2U, 0x07910FU, 0x4CAADCU, 0x356BA0U, 0x3E5033U, 0x67C3EEU, 0x2D9B05U, 0xB62810U, 0xFFF3EBU, 0xC4E03EU, + 0x8558A5U, 0xDE0B48U, 0xD5905BU, 0x8D71A2U, 0xA26A75U, 0xFBD8ECU, 0xB08982U, 0xAB1253U, 0xE2A1ECU, 0x79FB3FU, + 0x116E52U, 0x4A15C9U, 0x43861CU, 0x188FE7U, 0x537DF2U, 0x62E619U, 0x29D7C0U, 0x310C57U, 0x7A1F2EU, 0x25E5B8U, + 0xAC7451U, 0xC76F86U, 0xDE9C9FU, 0x959460U, 0xCF27B1U, 0xC6FC1EU, 0xBDEDCFU, 0xF416B0U, 0xEF0429U, 0xA49FEEU, + 0xBDEA17U, 0xFF7104U, 0x06A3F8U, 0x0D8A63U, 0x5219A6U, 0x5B62DDU, 0x00F348U, 0x6969B3U, 0x731A6EU, 0x38816DU, + 0x61D090U, 0x6A6343U, 0x33F9FEU, 0x18B8A5U, 0xC30340U, 0x8B10DAU, 0x98E80BU, 0xD1FB74U, 0xEA20F5U, 0xA5930AU, + 0xFC8E93U, 0xF75CC4U, 0xAF673DU, 0xA4E6BAU, 0xDF3D43U, 0x960F9CU, 0x0DD68DU, 0x44E572U, 0x1F7EB2U, 0x35AD09U, + 0x6C9554U, 0x6746A7U, 0x365D3AU, 0x7DFCF9U, 0x64A6C4U, 0x0B351FU, 0x118CEAU, 0x58DF61U, 0x836434U, 0x8A36CFU, + 0xF1AB5BU, 0xBA18A0U, 0xA343EDU, 0xE8C27EU, 0xF0F887U, 0xBB2B50U, 0xC03A69U, 0xC9C1A6U, 0x9A5317U, 0x9368C8U, + 0x5CB919U, 0x26A226U, 0x2F01EFU, 0x74D919U, 0x3DCA80U, 0x2631D7U, 0x6D223EU, 0x54BAA1U, 0x1E4950U, 0x47520BU, + 0x4CA79EU, 0x97BC75U, 0xBE3EA8U, 0xED479BU, 0xA4D446U, 0xBA4FF5U, 0xF13C39U, 0xE8A46AU, 0x83D7D7U, 0xDA4C0CU, + 0xD1DDF9U, 0x8AA7F2U, 0xC22427U, 0x793DDCU, 0x30CE45U, 0x2B5522U, 0x6007FBU, 0x39BE6CU, 0x32AD95U, 0x42560BU, + 0x4D426AU, 0x16D1B5U, 0x5F3A04U, 0x442BDBU, 0x2DF082U, 0xF6C225U, 0xFE59FCU, 0xA5880FU, 0xAEB312U, 0xF761C9U, + 0x9C582CU, 0x85CBB7U, 0xCE00C3U, 0xD43118U, 0x9DAB9DU, 0xEAF866U, 0xE3437BU, 0x381288U, 0x738955U, 0x6A3BF6U, + 0x2066ABU, 0x19D570U, 0x52DEC1U, 0x090E1EU, 0x00B5FFU, 0x5BE6E1U, 0x727D38U, 0x284CCFU, 0x639656U, 0xFA8531U, + 0xBD3CA8U, 0xD4EF77U, 0xCFC586U, 0x841489U, 0x9C0F78U, 0xD7BCA7U, 0x8E671EU, 0xA5774DU, 0xFE8481U, 0xF79F32U, + 0xAC0AEFU, 0x65F09CU, 0x5FF301U, 0x144ACAU, 0x0D193FU, 0x468224U, 0x13F0D1U, 0x18694AU, 0x63FA87U, 0x2B81F4U, + 0x30106DU, 0x790A9BU, 0xE2E952U, 0x8970CDU, 0xD003BCU, 0xDB9963U, 0x838AD2U, 0x88731DU, 0xD1E064U, 0xBAFFF3U, + 0xA10F2AU, 0xEC049DU, 0xBFD7D4U, 0xB7EE2BU, 0x4C7CBBU, 0x478760U, 0x1E9415U, 0x554D9EU, 0x4C7E6BU, 0x07E4B0U, + 0x3D35ADU, 0x741E4EU, 0x2F8D93U, 0x26FC20U, 0x7D667DU, 0x16B586U, 0x8B8E02U, 0xC91FD9U, 0xD0456CU, 0x9BF237U, + 0xC0EBCEU, 0xE92849U, 0xB29390U, 0xBBC3E7U, 0xE1787EU, 0xAA6B81U, 0x93B040U, 0xD8005FU, 0x411BAEU, 0x0AC870U, + 0x51F1D1U, 0x5D328EU, 0x362837U, 0x6799E0U, 0x6C4239U, 0x37711AU, 0x3EABC7U, 0x45BA3CU, 0x0D01A9U, 0x16D6F2U, + 0xDDCF17U, 0xC46D8CU, 0x8F3670U, 0xF6A723U, 0xFD5CBCU, 0xA74F5DU, 0xEAF582U, 0xF1A43BU, 0x903768U, 0x8B0CC5U, + 0xC0DC16U, 0x9957CBU, 0x1324F0U, 0x4ABD25U, 0x61AECEU, 0x38545AU, 0x73C701U, 0x68FEF4U, 0x212D6FU, 0x5B3382U, + 0x52C2D1U, 0x09494CU, 0x065ABFU, 0xDFA126U, 0x9CB149U, 0xA56A98U, 0xEE5927U, 0xF4C0F6U, 0xBD33B8U, 0xE62901U, + 0xCFB8D6U, 0x94D32FU, 0x9F40B8U, 0xC69AF1U, 0x8CAB0EU, 0x15309FU, 0x7E6360U, 0x21DA31U, 0x2848BAU, 0x733747U, + 0x72A6D4U, 0x08EDA8U, 0x435F7BU, 0x5A4CD6U, 0x119505U, 0x082658U, 0x433DE3U, 0xB8ED26U, 0xB0D6DDU, 0xEB05C8U, + 0xA2BC13U, 0xA9BEEAU, 0xD6656DU, 0xDF5614U, 0x848F82U, 0xC41C5BU, 0xDF26A4U, 0x94F7A5U, 0xADCC5AU, 0x665B8BU, + 0x3F1234U, 0x34A0EDU, 0x6E7BAAU, 0x076813U, 0x1CD1C4U, 0x55833DU, 0x4E1836U, 0x03A9E2U, 0x58F219U, 0x72418CU, + 0x2B09F7U, 0xA89A72U, 0xF1A1A9U, 0xBA7254U, 0x81EA47U, 0xC899BAU, 0xD20279U, 0x9B13C4U, 0xC0E09FU, 0xCB7E4BU, + 0xB25FF0U, 0xF98431U, 0xE4974EU, 0x2E6CD7U, 0x35FC00U, 0x5CE7A9U, 0x07147EU, 0x060D07U, 0x5D9F98U, 0x56E449U, + 0x0E65A6U, 0x659EB7U, 0x7C8D49U, 0x371790U, 0x6C6623U, 0xE5FD6EU, 0x9E6EBDU, 0x921600U, 0xC985D3U, 0x82DAEEU, + 0x9B7B25U, 0xD0E0F0U, 0xE1924BU, 0xAA091EU, 0xF158F5U, 0xF9E369U, 0x22F1BAU, 0x4B28C7U, 0x509B54U, 0x1B80BDU, + 0x024162U, 0x497B53U, 0x01A88CU, 0x3E1B5DU, 0x7502F2U, 0x6CD12BU, 0x27EB1CU, 0x7E7AC5U, 0xDDA113U, 0x8596BAU, + 0xCE5EEDU, 0xD54D14U, 0x9CF68BU, 0x87A54AU, 0xEE1C31U, 0xB58EA4U, 0xBFD55FU, 0xE66482U, 0xE93FA1U, 0x90AD7CU, + 0x5B04EFU, 0x405713U, 0x09CC48U, 0x13BFEDU, 0x522736U, 0x2914E3U, 0x22CFD8U, 0x7B5E05U, 0x3061E6U, 0x29B37FU, + 0x43BAA8U, 0x5849D1U, 0x91D25EU, 0xCEE0AFU, 0xC73971U, 0x9C2A40U, 0xB7919FU, 0xEF401EU, 0xA452E1U, 0xB5B9B8U, + 0xFEA80FU, 0x8533D6U, 0x8C4115U, 0xD7DA28U, 0x5F6BF3U, 0x043006U, 0x4FA39DU, 0x76DBD9U, 0x394C22U, 0x20C7BFU, + 0x6BB64CU, 0x312C41U, 0x187FB2U, 0x43C46FU, 0x0A55F4U, 0x192E81U, 0xD2BC4AU, 0xCBA5FBU, 0xA15624U, 0xF85DFDU, + 0xF38ECBU, 0xBA3602U, 0xA125F5U, 0xCEFE6CU, 0x97CF3BU, 0x9D55C2U, 0xC4A64DU, 0x4FBFBCU, 0x1468A3U, 0x7D4352U, + 0x6ED19DU, 0x270804U, 0x7D3B76U, 0x76A0ABU, 0x0FF018U, 0x0443D5U, 0x5D188EU, 0x16A93BU, 0x0932E0U, 0xC07015U, + 0xFACB1EU, 0xB39AC3U, 0xE80170U, 0xE3B3ADU, 0xBAEA5EU, 0xD17956U, 0xC042A9U, 0x8A9378U, 0x912DE7U, 0xD86E86U, + 0x83F559U, 0x2AC4E8U, 0x711F37U, 0x7A0D6EU, 0x26B4C9U, 0x6D6710U, 0x547CE7U, 0x1F8CFEU, 0x449720U, 0x4D3483U, + 0x16EF5AU, 0x1EFE2DU, 0x6D44B4U, 0xA6174BU, 0xBF8E8AU, 0xF4FD95U, 0xED6764U, 0x86D6BBU, 0xDC8912U, 0xD10A45U, + 0x8A799CU, 0x83E12AU, 0xF872F3U, 0xB10954U, 0xAA980DU, 0x6083D6U, 0x397163U, 0x3AE8B8U, 0x439BDDU, 0x481046U, + 0x1302BBU, 0x5AFB68U, 0x50E875U, 0x297396U, 0x26824AU, 0x7D98F1U, 0x344BA4U, 0xAF726FU, 0xE6F5DAU, 0x9C0F01U, + 0x971C38U, 0xCE85EFU, 0xC5F626U, 0x946D91U, 0xFFBDC8U, 0xE48637U, 0xAC15A6U, 0xB74C48U, 0x7EEE99U, 0x21B586U, + 0x0A0677U, 0x539FA8U, 0x18CC01U, 0x007652U, 0x4B67CFU, 0x70B43CU, 0x390FF1U, 0x625ECAU, 0x6BD01FU, 0x38E3C4U, + 0xB23870U, 0xCB893BU, 0x8093C6U, 0x994055U, 0xD679A8U, 0x8DAAFBU, 0xA4B176U, 0xFE018DU, 0xF7CA5CU, 0xACD963U, + 0xE762B2U, 0xFE323DU, 0x1589C4U, 0x0C5A92U, 0x4F432BU, 0x17F0ECU, 0x1CAA35U, 0x673B82U, 0x6E54DBU, 0x31C724U, + 0x785CA5U, 0x632C5AU, 0x29B70BU, 0x508490U, 0xDB5D6DU, 0x82CFEEU, 0x89B492U, 0xD22541U, 0xBB2EDCU, 0xA1DD27U, + 0xE04F62U, 0xFB56D9U, 0xB0A50CU, 0xF9BED7U, 0xC24EFAU, 0x8F5529U, 0x55C6D0U, 0x5E3B47U, 0x07383FU, 0x2CA2F0U, + 0x75D161U, 0x3E489EU, 0x25BB0FU, 0x6DA170U, 0x7630B1U, 0x174B2EU, 0x4CD8D7U, 0x470180U, 0x9E2339U, 0xD5B8FEU, + 0xE9EB27U, 0xA2521DU, 0xB941C8U, 0xF0BB23U, 0xAB2AB6U, 0xA271CDU, 0xD9C250U, 0xD3DC83U, 0x8A1D6EU, 0x41A67DU, + 0x58B580U, 0x3B6C5BU, 0x205ECEU, 0x6985A5U, 0x333471U, 0x3E27CAU, 0x65FD13U, 0x0CCE44U, 0x1747EDU, 0x5C143AU, + 0x45AF83U, 0x8F7F54U, 0xF6643DU, 0xFDD7A2U, 0xA68E73U, 0xAF3D8CU, 0xF4E79DU, 0xB5E073U, 0x8F59AAU, 0xC40A3DU, + 0x999044U, 0x922197U, 0xCB7A3AU, 0x60E9E1U, 0x3B90B4U, 0x73020FU, 0x6839DAU, 0x21FA71U, 0x3A632CU, 0x5151DFU, + 0x088A43U, 0x039B80U, 0x4260FDU, 0x18F36EU, 0x33EB97U, 0xEE1848U, 0xE503C9U, 0xBCA4B6U, 0xF7FC67U, 0xEC6FD8U, + 0x849C01U, 0x9F8506U, 0xD616FFU, 0x8D6C29U, 0x86FD90U, 0xFF26CFU, 0xF4150EU, 0x2C9EB1U, 0x6FEE60U, 0x74751BU, + 0x39E696U, 0x429F65U, 0x4B0DB8U, 0x1056ABU, 0x1AE756U, 0x43FC9DU, 0x282F29U, 0x318172U, 0x7A90E7U, 0xE36B1CU, + 0xA878D9U, 0xF2A0E2U, 0xDB133FU, 0x8008ECU, 0xC1D955U, 0xDAE292U, 0x9570EBU, 0xAC9B74U, 0xE68A85U, 0xBF514BU, + 0x34635AU, 0x6FFAA5U, 0x66A93CU, 0x1D12CBU, 0x54C382U, 0x4ED915U, 0x056AECU, 0x5C2D37U, 0x779402U, 0x2607C9U, + 0x2D5D1CU, 0x72ECA6U, 0xBAB7FBU, 0xA12408U, 0xC89C85U, 0xD3CF76U, 0x98542BU, 0xC177B8U, 0xCAAE45U, 0xB29CCEU, + 0xB9473BU, 0xE2D660U, 0xABEDF1U, 0xA03F1EU, 0x7926C4U, 0x1A95F1U, 0x044E2AU, 0x4D49FFU, 0x56B154U, 0x1FA209U, + 0x6419FAU, 0x6F4867U, 0x36D394U, 0x3C2199U, 0x653842U, 0x2EABB7U, 0x95C02CU, 0xDC525CU, 0x87CB93U, 0x8EB80AU, + 0xD423FDU, 0xF152A4U, 0xAAC003U, 0xE15BDAU, 0xF82A0DU, 0xB3B134U, 0xAAB3EBU, 0xC14C0AU, 0x1B5D95U, 0x128664U, + 0x49357AU, 0x002DA3U, 0x3BDE40U, 0x70C5DDU, 0x6954AEU, 0x23AE73U, 0x76ADE8U, 0x7D760DU, 0x064756U, 0x0FDCE3U, + 0xD40E38U, 0x9D37F5U, 0x87E4C6U, 0xECDF1AU, 0xB54EA9U, 0xBE1470U, 0xE7B71FU, 0xEC288EU, 0xB77951U, 0xDFC3A0U, + 0xC490BFU, 0x89095EU, 0x1ABA81U, 0x51E118U, 0x2853EFU, 0x234AB6U, 0x7B8910U, 0x703AC9U, 0x2B6216U, 0x62F127U, + 0x59CAECU, 0x101B59U, 0x4B2082U, 0xC1F2FFU, 0x88696CU, 0xB358A1U, 0xFA9752U, 0xAD844FU, 0xA63CB4U, 0xFFEF60U, + 0xF5F4EBU, 0x8C059EU, 0xC71F45U, 0xDCACF0U, 0x95772BU, 0x4E6622U, 0x67CDD5U, 0x3D9F0CU, 0x3406BBU, 0x6F75F2U, + 0x24EE0DU, 0x3D7E9CU, 0x520542U, 0x4396B3U, 0x09ADBCU, 0x527C45U, 0x5BF292U, 0xA0810BU, 0xE91878U, 0xF20BB5U, + 0xB9F10EU, 0xA1E0DBU, 0xEA33C0U, 0x938835U, 0x989BFEU, 0xC36342U, 0xCA6011U, 0x95FBECU, 0xFD0A6FU, 0x6E11B2U, + 0x25C3C1U, 0x3CFA5CU, 0x7769A7U, 0x0EB266U, 0x058079U, 0x5E1988U, 0x167E17U, 0x0DE5EFU, 0x44B428U, 0x7F0E31U, + 0x349DC6U, 0xEDC41FU, 0xE277A0U, 0xBA6DE1U, 0x99BE1EU, 0xC2178FU, 0x8B4450U, 0x90FF39U, 0xD9EFAAU, 0x823457U, + 0xA88785U, 0xF1DE98U, 0xFA4D73U, 0x3377E6U, 0x68A41DU, 0x43AD48U, 0x1A1AD3U, 0x14C836U, 0x4DF1EDU, 0x0622D0U, + 0x173903U, 0x7C88FEU, 0x27527DU, 0x2E41A5U, 0xF4FADAU, 0xFDBB4BU, 0x8601A4U, 0xCDD235U, 0xD4CB6AU, 0x9F7893U, + 0x862304U, 0xCCB3EDU, 0xB388BAU, 0xBA5B23U, 0xE1C0DCU, 0xE8A00DU, 0x3B3F27U, 0x500CF2U, 0x48D509U, 0x034694U, + 0x5A3CC7U, 0x51AD6AU, 0x0AB6B9U, 0x234544U, 0x785E57U, 0x30DE9AU, 0x2B2561U, 0x6036F4U, 0xDDCF8FU, 0x96DD5BU, + 0xCF46D0U, 0xCCB729U, 0x96A4FEU, 0xDF3FC7U, 0xE44D10U, 0xADC4F9U, 0xB61366U, 0xFD2837U, 0xA4B888U, 0x8EC359U, + 0x5750B6U, 0x5C49AFU, 0x07BA79U, 0x4A2080U, 0x517307U, 0x38DA7EU, 0x62C9ADU, 0x611230U, 0x38A2CBU, 0x33F98EU, + 0x4A4A35U, 0x0153E0U, 0x98815BU, 0xD23A06U, 0xD929C5U, 0x80E079U, 0xEBD7AAU, 0xF20D57U, 0xBD1C4CU, 0xE6A78DU, + 0xEF7472U, 0x954CE3U, 0x9CDF9CU, 0xCF8455U, 0x0437C2U, 0x1DFE3BU, 0x56EC6CU, 0x6F57D5U, 0x25061BU, 0x7E95AAU, + 0x772FF5U, 0x2C7C24U, 0x05C59BU, 0x5A965AU, 0x111D21U, 0x892DBCU, 0xC2F26FU, 0x9B6192U, 0xB81891U, 0xE38B6EU, + 0xEA91B6U, 0xB16221U, 0xF9FB48U, 0xC2C8DFU, 0x890226U, 0x9013F9U, 0xDBE848U, 0x02FB07U, 0x0D62D6U, 0x77906DU, + 0x3E8BB0U, 0x2538C3U, 0x6C614EU, 0x77F39CU, 0x141861U, 0x4D0D7AU, 0x47968FU, 0x1EE544U, 0x157DD1U, 0xCEEEAAU, + 0xA7953FU, 0xBC06D4U, 0xF57E09U, 0xABED3AU, 0xA2EEE3U, 0xD91734U, 0xD2849CU, 0x8BDEC3U, 0xC06F32U, 0xD174ADU, + 0x9BA77CU, 0x201C93U, 0x690C8AU, 0x22F77DU, 0x3BF4E4U, 0x702933U, 0x4B9B5AU, 0x0380C1U, 0x585134U, 0x556AEEU, + 0x0EF9CBU, 0x45A310U, 0x7C12CDU, 0xB7C97EU, 0xAFEA23U, 0xEC72C0U, 0xB7215DU, 0x9E9A8EU, 0xC50BF3U, 0xCC5068U, + 0x97E28DU, 0xDDB916U, 0xC42846U, 0xAF93B9U, 0xF2D020U, 0x796CC7U, 0x223F9EU, 0x2BA429U, 0x5095F0U, 0x18473FU, + 0x03DC8EU, 0x40EFD1U, 0x593620U, 0x1225BFU, 0x6BCF76U, 0x605E40U, 0xBA6599U, 0xF3B66AU, 0xE8AEF7U, 0x851DBCU, + 0x9EC649U, 0xD5D5D2U, 0x8C2C27U, 0x863E7CU, 0xDFB5D9U, 0xF4C002U, 0xA55BDFU, 0xEEE9ECU, 0x75B020U, 0x3C23D3U, + 0x06584AU, 0x4FCB15U, 0x1453A4U, 0x1F306BU, 0x42AB9AU, 0x09FA05U, 0x30415CU, 0x7A53ABU, 0x61AA22U, 0x2839D5U, + 0xF3228CU, 0xDAD032U, 0x89C9E3U, 0x820A2CU, 0xCAB91DU, 0x91A4C6U, 0x985673U, 0xE34DB8U, 0xA8DCE5U, 0xB52756U, + 0xFE358BU, 0xE6EE78U, 0x0DDF75U, 0x5654AFU, 0x5F075AU, 0x04BFC1U, 0x0D2CB4U, 0x56577FU, 0x34C6C2U, 0x2D9D11U, + 0x662F48U, 0x3FB4FFU, 0x34E536U, 0x4F4E89U, 0xC61C58U, 0x988107U, 0xD132A7U, 0xCA6978U, 0x81D881U, 0xB8C296U, + 0xF3114FU, 0xAA2AA8U, 0xA0FB31U, 0xF37142U, 0xDA429FU, 0x819B24U, 0x4888E1U, 0x5333FAU, 0x1AE30FU, 0x40D0D5U, + 0x6F0B68U, 0x36182BU, 0x3DA0F6U, 0x646345U, 0x2F7898U, 0x14CDF3U, 0x5C9666U, 0xC704BDU, 0x8E7F4CU, 0xDDEED3U, + 0xD655BAU, 0xAF062DU, 0xE49EF5U, 0xFDFD02U, 0xB7661BU, 0xA8F7F4U, 0xC18D25U, 0x9A1E9AU, 0x9305CBU, 0x48F414U, + 0x43EFB5U, 0x1B1D6AU, 0x708413U, 0x698780U, 0x2A7C4DU, 0x6168BFU, 0x78F3A2U, 0x130059U, 0x0B1BCCU, 0x40CA07U, + 0x1FF072U, 0x9663E9U, 0xCD9A14U, 0xE499C7U, 0xBF0AEAU, 0xF57239U, 0xECE1E4U, 0xA7BA5FU, 0xDE098FU, 0xD591E0U, + 0x86E271U, 0x8F79AEU, 0xD52817U, 0x1C8350U, 0x2711A9U, 0x684C3EU, 0x71FFE7U, 0x3AE490U, 0x633619U, 0x498FE6U, + 0x10DC37U, 0x1B670DU, 0x4066D8U, 0x09BC13U, 0x328FAEU, 0xFB16FDU, 0xA9C500U, 0xA2FF93U, 0xFB2C5EU, 0xF03565U, + 0x8D86B0U, 0xC65D4BU, 0xDD7DCEU, 0x95E615U, 0x8EB169U, 0xE708FAU, 0xBCDB03U, 0x37C1C4U, 0x6E72FDU, 0x25232AU, + 0x3DB8F3U, 0x5ECA4CU, 0x45430DU, 0x0CF0B2U, 0x57AB61U, 0x5E3ABCU, 0x210087U, 0x2BD343U, 0xF248B8U, 0xB9392DU, + 0xA0A376U, 0xEBB09FU, 0x905908U, 0x99CAF1U, 0xD3F5A6U, 0xCA251FU, 0x813ED0U, 0xF2CD01U, 0xFBD63EU, 0xA046EEU, + 0x29BD51U, 0x76AE98U, 0x3C274FU, 0x055476U, 0x4ECEA5U, 0x573F58U, 0x1C24DBU, 0x47B786U, 0x6ECC7DU, 0x345CE8U, + 0x7D0703U, 0x66B456U, 0xAF3DECU, 0xBC6F31U, 0xD7D0A2U, 0x8EC1CFU, 0x80321CU, 0xD9A9A1U, 0xD2FB7AU, 0xA9422BU, + 0xE05184U, 0xFB8A55U, 0xB22AAAU, 0xE831B3U, 0x63E264U, 0x1ADB8CU, 0x11081BU, 0x4832E2U, 0x0BA1BDU, 0x10781CU, + 0x784BC3U, 0x679052U, 0x2E902DU, 0x752BFCU, 0x7EFC57U, 0x27C58AU, 0xCC57D9U, 0xD40C64U, 0x9FBFB6U, 0x84665BU, + 0xCD7540U, 0xB6CF95U, 0xBF8E6EU, 0xE415FBU, 0xE62690U, 0xBFFE0DU, 0xF04DFEU, 0xC91623U, 0x028520U, 0x19BCD9U, + 0x506E06U, 0x0AEDB6U, 0x23D4E9U, 0x780728U, 0x331997U, 0x3AE84EU, 0x6173B9U, 0x6840A0U, 0x129B67U, 0x598B9EU, + 0xC87009U, 0x877370U, 0x9EEAEBU, 0xF5190EU, 0xAC03D4U, 0xA690C1U, 0xFDE93AU, 0xB47AF7U, 0xAF8044U, 0xC69119U, + 0xDD0ACAU, 0x166977U, 0x4EF0BCU, 0x45E2C9U, 0x3C1D52U, 0x3F8E87U, 0x64D73CU, 0x296574U, 0x327E83U, 0x7A8F1AU, + 0x0114EDU, 0x0A1734U, 0x53EF3BU, 0xD8FCCAU, 0x812715U, 0xEA94A4U, 0xF185EBU, 0xB95F3AU, 0xA26C85U, 0xEBB55CU, + 0xB0862AU, 0x930CA3U, 0xCEDD70U, 0x85E6CDU, 0x9D7196U, 0x562A63U, 0x6D9AE8U, 0x24411DU, 0x7F5246U, 0x76EBDBU, + 0x2DB928U, 0x2712E5U, 0x5E83D7U, 0x15D80AU, 0x0C6BD1U, 0x473170U, 0x54A02FU, 0xB99B9EU, 0xE34841U, 0xEAD090U, + 0xB1E33FU, 0xFA2866U, 0xE31991U, 0x88C208U, 0x8154FFU, 0xDB6FB7U, 0x92BE28U, 0x89A5D9U, 0xE25606U, 0x7BCE37U, + 0x30FDFCU, 0x693E21U, 0x6F2792U, 0x3495CFU, 0x5DCE6CU, 0x465DB1U, 0x0FA46AU, 0x14B75FU, 0x5F2D85U, 0x275C60U, + 0x2CC7FBU, 0xF56486U, 0xFE3C55U, 0xA5ABC8U, 0xECD02BU, 0xD743F2U, 0x9FDAC5U, 0xC0A81CU, 0xC33383U, 0x9A2262U, + 0xB1D93DU, 0xE8DA8DU, 0x232252U, 0x39B19BU, 0x70AAACU, 0x6B5975U, 0x024182U, 0x59921BU, 0x522974U, 0x0B38A5U, + 0x01F33EU, 0x78C1CBU, 0x3758D0U, 0x242F3DU, 0xEDB4EFU, 0xB66672U, 0xBF5701U, 0xC5CCDCU, 0xCE9F77U, 0x9726A2U, + 0xDCA4F9U, 0xC5FF4CU, 0xAE4E87U, 0xB51576U, 0xFDA7E9U, 0xA63C90U, 0x2F6D47U, 0x74D6CFU, 0x1BC538U, 0x0A1D21U, + 0x413EDEU, 0x58E50FU, 0x127480U, 0x6B4BF1U, 0x60992EU, 0x2BA297U, 0x327340U, 0x79E809U, 0xA0DABAU, 0x8A0367U, + 0xD1009DU, 0x98BB98U, 0x836A63U, 0xCE70F6U, 0xF5832DU, 0xB69850U, 0xEE29D3U, 0xE5732EU, 0xBCE0FDU, 0xB75962U, + 0x4C1A13U, 0x0589DCU, 0x1EF165U, 0x5666B7U, 0x4DFDEAU, 0x268E59U, 0x7F1794U, 0x74256FU, 0x29FE7AU, 0x626F81U, + 0x700404U, 0x1996DFU, 0x828FA2U, 0xCB7C31U, 0x9067CCU, 0x9B940EU, 0xE20C17U, 0xE81FE8U, 0xB1E439U, 0xFAF586U, + 0xE17FC7U, 0xA88C18U, 0xD397A1U, 0x5E4276U, 0x04794FU, 0x0FEB88U, 0x5E9271U, 0x3501E6U, 0x2C9A3EU, 0x67EA51U, + 0x7C61C0U, 0x34323BU, 0x6F89EEU, 0x4618F5U, 0x1D4218U, 0xD4F1CBU, 0xCFE876U, 0x841B25U, 0xB888F8U, 0xF3D053U, + 0xAA7386U, 0xA168BCU, 0xF2BB69U, 0xFB8792U, 0x80541FU, 0xC8CF4CU, 0xC3FEB5U, 0x182522U, 0x1117CBU, 0x6A9E9CU, + 0x234D05U, 0x3876FAU, 0x72A42BU, 0x2FBD84U, 0x240ED4U, 0x5DD54BU, 0x56C4B2U, 0x057E65U, 0x4C2D4CU, 0xD7849BU, + 0xBFD762U, 0xA44DF9U, 0xEFFEACU, 0xB6A347U, 0xBD30D2U, 0xC40B29U, 0x8FDB74U, 0x9540E6U, 0xDC330BU, 0xC3BAD8U, + 0x8A89E5U, 0x71533EU, 0x7AC0BBU, 0x2BB140U, 0x212A11U, 0x7838AEU, 0x13C17FU, 0x08D290U, 0x414989U, 0x1AA85EU, + 0x13B2A6U, 0x494131U, 0x625AD8U, 0xBBCF87U, 0xF43516U, 0xED26E9U, 0xA6BF78U, 0x9FCC17U, 0xDD57CEU, 0x86B75DU, + 0x8FACA0U, 0xD43FE3U, 0x9D445EU, 0xA6D584U, 0x6DCF71U, 0x753C6AU, 0x3EA5AFU, 0x67F654U, 0x4C4CC9U, 0x134DBAU, + 0x1AB667U, 0x4125E4U, 0x097E19U, 0x12CA0AU, 0x71D1F3U, 0x78022CU, 0xA33BACU, 0xEAA953U, 0xF17A02U, 0x9B53BDU, + 0xC28074U, 0xC9BB83U, 0x90299AU, 0x9BF04DU, 0xC4C3B4U, 0xAD583BU, 0xB7084AU, 0xFEB3D1U, 0x656004U, 0x2E69FEU, + 0x5FDAF3U, 0x548000U, 0x0D37DDU, 0x472E4EU, 0x5CFD33U, 0x1546F8U, 0x2E164DU, 0x678D96U, 0x3CBEE3U, 0x337768U, + 0xEBE5BDU, 0xC09E47U, 0x990D5EU, 0xD234A9U, 0xC9E720U, 0x887DF7U, 0xD34C0EU, 0xFB9711U, 0xA084E0U, 0xA96C2FU, + 0xF27FBEU, 0xB9E4C1U, 0x001318U, 0x4B02AFU, 0x56B867U, 0x1CEB30U, 0x477289U, 0x4E8152U, 0x358AF7U, 0x3C1AACU, + 0x676159U, 0x24F2C2U, 0x3C6917U, 0x57197CU, 0x8E82E1U, 0x85F112U, 0xDE68CFU, 0xD77BDDU, 0x8C9130U, 0xE400EBU, + 0xFB5B5EU, 0xB0E885U, 0xA9F6D4U, 0xE2277BU, 0x9B9CA2U, 0x108F15U, 0x5A764CU, 0x0B64ABU, 0x00AF32U, 0x599CEDU, + 0x72059DU, 0x29D702U, 0x60ECE3U, 0x7A7D3CU, 0x330625U, 0x0C95D6U, 0x474D0BU, 0x9E7EA8U, 0x95FDF5U, 0xCCA666U, + 0x86179BU, 0xBD8D40U, 0xFCDA65U, 0xE763BFU, 0xAE304AU, 0xF58AD1U, 0xDE9B9CU, 0x86406FU, 0x8DE3F2U, 0x54B801U, + 0x1B28D8U, 0x0213D7U, 0x69C026U, 0x7259B9U, 0x3A6B48U, 0x61B017U, 0x68819FU, 0x135A68U, 0x50D9B1U, 0x49E386U, + 0x02325FU, 0x9A29B0U, 0xD19E23U, 0xAAC77EU, 0xA3558DU, 0xFCAE04U, 0xF5BFF3U, 0xAE04AAU, 0xC44635U, 0xDDDDC5U, + 0x966C4AU, 0xCF373BU, 0xC4A4E4U, 0x1FD47DU, 0x3E4F8AU, 0x64DC43U, 0x2DA574U, 0x3637ADU, 0x7D5C56U, 0x44CFC3U, + 0x0BD688U, 0x52257DU, 0x59BBE7U, 0x03AA1AU, 0x4A5119U, 0xF142C4U, 0xB89A37U, 0xB329AAU, 0xE822D1U, 0xA9D114U, + 0x93C88FU, 0xDA5A7AU, 0xC1A121U, 0x8AB090U, 0xD36B5EU, 0xDC58A7U, 0xA5C0B0U, 0x2F8369U, 0x74389EU, 0x3DAB17U, + 0x26D368U, 0x4F40F9U, 0x141F26U, 0x1DAEC7U, 0x473558U, 0x446721U, 0x1DDEF6U, 0x769D6EU, 0xEF0E8DU, 0xA434D0U, + 0xBFE56BU, 0xF35EBEU, 0x884D45U, 0x819440U, 0xDAA69BU, 0x917D26U, 0x88ECF5U, 0xC3C788U, 0xFB150BU, 0xB02ED6U, + 0x63BF24U, 0x6A6439U, 0x3153D2U, 0x188B03U, 0x43989CU, 0x0923EDU, 0x147232U, 0x5FF99BU, 0x060B4CU, 0x2D10B5U, + 0x76A1A2U, 0x7FFA7BU, 0xA568D4U, 0xECD104U, 0xD7827BU, 0x9C19EAU, 0x8D6831U, 0xC6E2DCU, 0x9F71CFU, 0x950A32U, + 0xEE9BE1U, 0xA3A16CU, 0xB8761FU, 0xF16FC2U, 0x6A9C79U, 0x010FACU, 0x491786U, 0x52F453U, 0x1BEF88U, 0x007C35U, + 0x4B8566U, 0x32978FU, 0x316C18U, 0x697DC1U, 0x62E6BEU, 0x3B142FU, 0xD40DC0U, 0xCFCE11U, 0x86F58EU, 0xDD66F6U, + 0xD53E31U, 0x8E8988U, 0xA5125FU, 0xFC6366U, 0xB7F9B9U, 0xAEAA78U, 0xE513C3U, 0xD69096U, 0x1ECB6DU, 0x4579F8U, + 0x4C6033U, 0x13B34EU, 0x5888DCU, 0x615821U, 0x2AE3F2U, 0x32F0FFU, 0x792B04U, 0x220A91U, 0x0B906AU, 0xD0432BU, + 0xD97294U, 0x82AD4DU, 0xC8BE9AU, 0xD90623U, 0xB2D564U, 0xEBEE9CU, 0xE02D03U, 0xBF35D2U, 0xB686ADU, 0xCCDD2CU, + 0x854CD3U, 0x1EF70AU, 0x55A51DU, 0x4C1CE4U, 0x074F67U, 0x7ED49AU, 0x7476C9U, 0x2F2F75U, 0x26BCBEU, 0x75876BU, + 0x1C5650U, 0x07C885U, 0x48BB7EU, 0x9022F3U, 0x9B11A0U, 0xC2CA5DU, 0xE9C8CEU, 0xA07133U, 0xFBA238U, 0xF0B9E9U, + 0xA84917U, 0x835286U, 0xDAC179U, 0x913830U, 0x822B87U, 0x4BD95EU, 0x30D289U, 0x3C43A0U, 0x67B87FU, 0x6CAA8EU, + 0x353311U, 0x7E4440U, 0x47DFABU, 0x0C8E3FU, 0x1634C4U, 0x5FA7D9U, 0x04CC0AU, 0xAD5DE7U, 0xF64774U, 0xBDB409U, + 0xAC2DD2U, 0xE67E67U, 0xFBC5ACU, 0x90D5F9U, 0xCB0E42U, 0xC23D9FU, 0x99B67DU, 0x9047E4U, 0xEA5DB3U, 0x218E0AU, + 0x38B7D5U, 0x732034U, 0x6AFA2BU, 0x21CBFAU, 0x5A1005U, 0x5B039CU, 0x01A8FBU, 0x4C7822U, 0x574395U, 0x3CD04DU, + 0xA5811AU, 0xEE3BB3U, 0xB76868U, 0xBDF19DU, 0xE64286U, 0xCF1943U, 0x949BF8U, 0xDDA225U, 0xC67156U, 0x8FCACBU, + 0xF59B08U, 0xF605F5U, 0x2B36EFU, 0x20EF1AU, 0x797CC1U, 0x324664U, 0x1985BFU, 0x419CE4U, 0x4A6F51U, 0x13748AU, + 0x58C42FU, 0x631F74U, 0x2A0CA1U, 0x71F51AU, 0xF9E7D7U, 0xA27CA5U, 0xA99F38U, 0xD886EBU, 0x973516U, 0x8E6F1DU, + 0xC5FEECU, 0xDF0133U, 0xB61282U, 0xED8ADDU, 0xE4F954U, 0xBF7AA3U, 0x74617AU, 0x6D904DU, 0x070A95U, 0x1E795AU, + 0x55E0EBU, 0x0EF334U, 0x0F0845U, 0x7098CAU, 0x798313U, 0x2360E0U, 0x687BFDU, 0x71AB0EU, 0xBA10C3U, 0x830370U, + 0xC8FA2DU, 0x93EDB7U, 0x9B3742U, 0xC00689U, 0xA99DBCU, 0xB25E67U, 0xF964BAU, 0xE0F509U, 0xA7AE44U, 0xFF1DB7U, + 0x54C42EU, 0x0DF6F1U, 0x066D90U, 0x5D3C0EU, 0x1487FFU, 0x2F8460U, 0x675E19U, 0x3CEFDEU, 0x37B447U, 0x6E27B0U, + 0x651369U, 0x9CC856U, 0xD77B97U, 0xC9604CU, 0x88B1F9U, 0x939BA2U, 0xFA4856U, 0xB1D1DDU, 0xAAE200U, 0xE33873U, + 0xB829EEU, 0xB0D20DU, 0xCBC190U, 0x407AEBU, 0x19AA3EU, 0x52A1A5U, 0x4B1240U, 0x204B1BU, 0x3ED9A2U, 0x7F2274U, + 0x2437ADU, 0x2DAC8AU, 0x76DF53U, 0x5D45ACU, 0x04F43DU, 0xCEBFE2U, 0xD72CC3U, 0x9C551CU, 0xE7C7E5U, 0xEEDC72U, + 0xB52D1BU, 0xBCB6CCU, 0xE6A454U, 0xA95FA7U, 0x904EFAU, 0xD3A551U, 0xCA3684U, 0x01265FU, 0x5ADD6AU, 0x72CEB1U, + 0x29135CU, 0x60A1CFU, 0x7BBA92U, 0x304921U, 0x2950FCU, 0x42D316U, 0x1AA903U, 0x1138F8U, 0x48E329U, 0xC7D0A6U, + 0xBC48DFU, 0xFD1B08U, 0xE6A0B1U, 0xAE3366U, 0xF55AAFU, 0xFEC898U, 0x879341U, 0x8C22FEU, 0xD5392EU, 0x9EEA61U, + 0x8456D0U, 0x6D450BU, 0x769EF6U, 0x3FADE5U, 0x606508U, 0x6BD6DBU, 0x3ACD46U, 0x101C3DU, 0x5927F8U, 0x02F543U, + 0x096C96U, 0x505FCCU, 0xBB8C71U, 0xA296B2U, 0xE8370FU, 0xF36C5CU, 0xBADF85U, 0xE1063AU, 0xC814FBU, 0x97AF04U, + 0x9CFA15U, 0xC461EAU, 0x87D23BU, 0xBE88B4U, 0x7509CCU, 0x2E721BU, 0x27E1A2U, 0x7C5965U, 0x750A7CU, 0x0F9183U, + 0x44A052U, 0x5D7BE9U, 0x1669ACU, 0x0F9277U, 0x6013CAU, 0x3B0819U, 0xB3FA65U, 0xE0E3E6U, 0xA9103BU, 0xB28BC0U, + 0xDB9ED5U, 0xC0642EU, 0x8B77EBU, 0xD3EC50U, 0xD80D89U, 0xA1179EU, 0xAAC477U, 0xF1F5A0U, 0x386E19U, 0x271D4FU, + 0x6F8596U, 0x541639U, 0x1F6DE8U, 0x4EFE97U, 0x45B706U, 0x1C05D9U, 0x779E30U, 0x6DCF27U, 0x2474DEU, 0x3F664DU, + 0xF69BB0U, 0xAD08FBU, 0x86536FU, 0xDFE094U, 0xD1E841U, 0x883B6AU, 0xC300B7U, 0xE8D164U, 0xB16BD9U, 0xF2788AU, + 0xEBA167U, 0xA192FCU, 0x3A0929U, 0x53DBD2U, 0x08F2C3U, 0x01212DU, 0x5A3ABCU, 0x518B43U, 0x29D11AU, 0x62628DU, + 0x7FFD64U, 0x34ACB3U, 0x6F1E8AU, 0xE64555U, 0x95C494U, 0x9D7F2BU, 0xC62C7AU, 0x8DB485U, 0x94871DU, 0xFF5CDEU, + 0xE6EFE3U, 0xADB730U, 0xF524CFU, 0xFE0F56U, 0xA5DE31U, 0x48C5E8U, 0x53377FU, 0x1AAE86U, 0x01BD59U, 0x4B4678U, + 0x3A50A7U, 0x31E977U, 0x683ACCU, 0x633189U, 0x38C072U, 0x71DAEFU, 0x4B493CU, 0x82B001U, 0x99A3C2U, 0xD2383FU, + 0x8F4AA4U, 0xA4D3D1U, 0xFDA00AU, 0xB62B8FU, 0xACBB75U, 0xE5C028U, 0xF6539BU, 0x9F4242U, 0xC4B985U, 0x4F2FBCU, + 0x167463U, 0x1CC5D2U, 0x65DE1DU, 0x2E3C4CU, 0x35A5F3U, 0x78F622U, 0x234DDDU, 0x0A5C55U, 0x408622U, 0x5BB5FBU, + 0x122E6CU, 0xC1FF95U, 0xC8C4DEU, 0xB3066BU, 0xB83FB0U, 0xE0AC25U, 0xAB775EU, 0xB24793U, 0xD9DC20U, 0x828BFDU, + 0x8F30AFU, 0xD46102U, 0xDCDBD9U, 0x07582CU, 0x6E0137U, 0x75B2C6U, 0x3EE809U, 0x2F7990U, 0x64C2E7U, 0x1C913EU, + 0x170A89U, 0x4C3A40U, 0x45E9D6U, 0x1E42AFU, 0x571370U, 0xE889C1U, 0xA2BA0EU, 0xFB635FU, 0xF070E0U, 0xA9CF39U, + 0x821DDAU, 0xD904C7U, 0x90F734U, 0x82FCE9U, 0xCB4D72U, 0xD09716U, 0x3B848DU, 0x623D78U, 0x696EA3U, 0x30F4BEU, + 0x7A075DU, 0x451E80U, 0x0C8D33U, 0x17E66EU, 0x5E76B5U, 0x050D14U, 0x0E9ECBU, 0x7607BAU, 0xF57524U, 0xACEAC5U, + 0xE7F91AU, 0xFC0083U, 0x9583F4U, 0xCED96DU, 0xC6688AU, 0x9D7353U, 0x92804CU, 0xCB11BDU, 0xA00B62U, 0xA9F8C3U, + 0x72E398U, 0x783244U, 0x2118F7U, 0x4A8B2AU, 0x5B5249U, 0x1061D4U, 0x09FA2FU, 0x428ABAU, 0x1911F1U, 0x31C604U, + 0x6AFD9FU, 0x276D62U, 0xBC2631U, 0xF795B8U, 0xCE4C4EU, 0x855F97U, 0xDDE520U, 0xD6B479U, 0x8D0FB6U, 0x8C1C07U, + 0xF7C6D8U, 0xBE77A9U, 0xA53C36U, 0xEFAFDFU, 0x369648U, 0x1D4411U, 0x40DFE6U, 0x4BEE7EU, 0x103595U, 0x5902C0U, + 0x43D85BU, 0x2AC9AEU, 0x316265U, 0x7AB158U, 0x23A18BU, 0x201A56U, 0xD949E5U, 0x93F2A8U, 0x882313U, 0xC139C6U, + 0xDA8A3CU, 0x97D329U, 0xEC50E2U, 0xE7AA13U, 0xBFBB8CU, 0xB42075U, 0xED5322U, 0x06C8ABU, 0x1DF85CU, 0x542785U, + 0x0FB4BAU, 0x0FCD7BU, 0x544FA4U, 0x7F5414U, 0x26A54BU, 0x6D3EF2U, 0x702D31U, 0x3BD7CCU, 0x13C6DFU, 0xC83D02U, + 0x83AEF9U, 0x9AB77CU, 0xD15507U, 0xC84ED2U, 0xA3DF49U, 0xF9A4BDU, 0xF836F6U, 0xA3ED4BU, 0xEADC98U, 0xD14B05U, + 0x9A30E6U, 0x03A0BFU, 0x4D6B00U, 0x1458D1U, 0x1FC12EU, 0x64932FU, 0x6D28F0U, 0x36BB09U, 0x7FE29FU, 0x6551E6U, + 0x0E0B21U, 0x57AAB8U, 0x54B147U, 0x8D6216U, 0x86DBA9U, 0xDDC968U, 0xB412F3U, 0xAA218EU, 0xE3FC5DU, 0xF86EF0U, + 0xB35523U, 0xCA945FU, 0xC1AFCCU, 0x983C11U, 0xD264FAU, 0x49D7EFU, 0x000C14U, 0x3B1FC1U, 0x7AA75AU, 0x21F4B7U, + 0x2A6FA4U, 0x728E5DU, 0x5D958AU, 0x042713U, 0x4F767DU, 0x54EDACU, 0x1D5E13U, 0x8604C0U, 0xEE91ADU, 0xB5EA36U, + 0xBC79E3U, 0xE77018U, 0xAC820DU, 0x9D19E6U, 0xD6283FU, 0xCEF3A8U, 0x85E0D1U, 0xDA1A47U, 0x538BAEU, 0x389079U, + 0x216360U, 0x6A6B9FU, 0x30D84EU, 0x3903E1U, 0x421230U, 0x0BE94FU, 0x10FBD6U, 0x5B6011U, 0x4215E8U, 0x008EFBU, + 0xF95C07U, 0xF2759CU, 0xADE659U, 0xA49D22U, 0xFF0CB7U, 0x96964CU, 0x8CE591U, 0xC77E92U, 0x9E2F6FU, 0x959CBCU, + 0xCC0601U, 0xE7475AU, 0x3CFCBFU, 0x74EF25U, 0x6717F4U, 0x2E048BU, 0x15DF0AU, 0x5A6CF5U, 0x03716CU, 0x08A33BU, + 0x5098C2U, 0x5B1945U, 0x20C2BCU, 0x69F063U, 0xF22972U, 0xBB1A8DU, 0xE0814DU, 0xCA52F6U, 0x936AABU, 0x98B958U, + 0xC9A2C5U, 0x820306U, 0x9B593BU, 0xF4CAE0U, 0xEE7315U, 0xA7209EU, 0x7C9BCBU, 0x75C930U, 0x0E54A4U, 0x45E75FU, + 0x5CBC12U, 0x173D81U, 0x0F0778U, 0x44D4AFU, 0x3FC596U, 0x363E59U, 0x65ACE8U, 0x6C9737U, 0xA346E6U, 0xD95DD9U, + 0xD0FE10U, 0x8B26E6U, 0xC2357FU, 0xD9CE28U, 0x92DDC1U, 0xAB455EU, 0xE1B6AFU, 0xB8ADF4U, 0xB35861U, 0x68438AU, + 0x41C157U, 0x12B864U, 0x5B2BB9U, 0x45B00AU, 0x0EC3C6U, 0x175B95U, 0x7C2828U, 0x25B3F3U, 0x2E2206U, 0x75580DU, + 0x3DDBD8U, 0x86C223U, 0xCF31BAU, 0xD4AADDU, 0x9FF804U, 0xC64193U, 0xCD526AU, 0xBDA9F4U, 0xB2BD95U, 0xE92E4AU, + 0xA0C5FBU, 0xBBD424U, 0xD20F7DU, 0x093DDAU, 0x01A603U, 0x5A77F0U, 0x514CEDU, 0x089E36U, 0x63A7D3U, 0x7A3448U, + 0x31FF3CU, 0x2BCEE7U, 0x625462U, 0x150799U, 0x1CBC84U, 0xC7ED77U, 0x8C76AAU, 0x95C409U, 0xDF9954U, 0xE62A8FU, + 0xAD213EU, 0xF6F1E1U, 0xFF4A00U, 0xA4191EU, 0x8D82C7U, 0xD7B330U, 0x9C69A9U, 0x057ACEU, 0x42C357U, 0x2B1088U, + 0x303A79U, 0x7BEB76U, 0x63F087U, 0x284358U, 0x7198E1U, 0x5A88B2U, 0x017B7EU, 0x0860CDU, 0x53F510U, 0x9A0F63U, + 0xA00CFEU, 0xEBB535U, 0xF2E6C0U, 0xB97DDBU, 0xEC0F2EU, 0xE796B5U, 0x9C0578U, 0xD47E0BU, 0xCFEF92U, 0x86F564U, + 0x1D16ADU, 0x768F32U, 0x2FFC43U, 0x24669CU, 0x7C752DU, 0x778CE2U, 0x2E1F9BU, 0x45000CU, 0x5EF0D5U, 0x13FB62U, + 0x40282BU, 0x4811D4U, 0xB38344U, 0xB8789FU, 0xE16BEAU, 0xAAB261U, 0xB38194U, 0xF81B4FU, 0xC2CA52U, 0x8BE1B1U, + 0xD0726CU, 0xD903DFU, 0x829982U, 0xE94A79U, 0x7471FDU, 0x36E026U, 0x2FBA93U, 0x640DC8U, 0x3F1431U, 0x16D7B6U, + 0x4D6C6FU, 0x443C18U, 0x1E8781U, 0x55947EU, 0x6C4FBFU, 0x27FFA0U, 0xBEE451U, 0xF5378FU, 0xAE0E2EU, 0xA2CD71U, + 0xC9D7C8U, 0x98661FU, 0x93BDC6U, 0xC88EE5U, 0xC15438U, 0xBA45C3U, 0xF2FE56U, 0xE9290DU, 0x2230E8U, 0x3B9273U, + 0x70C98FU, 0x0958DCU, 0x02A343U, 0x58B0A2U, 0x150A7DU, 0x0E5BC4U, 0x6FC897U, 0x74F33AU, 0x3F23E9U, 0x66A834U, + 0xECDB0FU, 0xB542DAU, 0x9E5131U, 0xC7ABA5U, 0x8C38FEU, 0x97010BU, 0xDED290U, 0xA4CC7DU, 0xAD3D2EU, 0xF6B6B3U, + 0xF9A540U, 0x205ED9U, 0x634EB6U, 0x5A9567U, 0x11A6D8U, 0x0B3F09U }; + +const unsigned int A_TABLE[] = { 0U, 4U, 8U, 12U, 16U, 20U, 24U, 28U, 32U, 36U, 40U, 44U, + 48U, 52U, 56U, 60U, 64U, 68U, 1U, 5U, 9U, 13U, 17U, 21U }; +const unsigned int B_TABLE[] = { 25U, 29U, 33U, 37U, 41U, 45U, 49U, 53U, 57U, 61U, 65U, 69U, + 2U, 6U, 10U, 14U, 18U, 22U, 26U, 30U, 34U, 38U, 42U }; +const unsigned int C_TABLE[] = { 46U, 50U, 54U, 58U, 62U, 66U, 70U, 3U, 7U, 11U, 15U, 19U, + 23U, 27U, 31U, 35U, 39U, 43U, 47U, 51U, 55U, 59U, 63U, 67U, 71U }; + +const unsigned char AMBE_SILENCE[] = {0xB9U, 0xE8U, 0x81U, 0x52U, 0x61U, 0x73U, 0x00U, 0x2AU, 0x6BU}; + +CModeConv::CModeConv() : +m_m17N(0U), +m_dmrN(0U), +m_M17(5000U, "DMR2M17"), +m_DMR(5000U, "M172DMR"), +m_m17GainMultiplier(1), +m_m17Attenuate(false) +{ + m_mbe = new MBEVocoder(); + m_c2 = new CCodec2(true); +} + +CModeConv::~CModeConv() +{ +} + +void CModeConv::setM17GainAdjDb(std::string dbstring) +{ + float db = std::stof(dbstring); + + float ratio = powf(10.0, (db/10.0)); + if(db < 0){ + ratio = 1/ratio; + m_m17Attenuate = true; + } + m_m17GainMultiplier = (uint16_t)roundf(ratio); +} + +void CModeConv::putDMRHeader() +{ + const uint8_t quiet[] = { 0x00u, 0x01u, 0x43u, 0x09u, 0xe4u, 0x9cu, 0x08u, 0x21u }; + + m_M17.addData(&TAG_HEADER, 1U); + m_M17.addData(quiet, 8U); + m_m17N += 1U; +} + +void CModeConv::putDMREOT() +{ + const uint8_t quiet[] = { 0x00u, 0x01u, 0x43u, 0x09u, 0xe4u, 0x9cu, 0x08u, 0x21u }; + + m_M17.addData(&TAG_EOT, 1U); + m_M17.addData(quiet, 8U); + m_m17N += 1U; +} + +void CModeConv::putDMR(unsigned char* data) +{ + assert(data != NULL); + + int16_t audio[160U]; + uint8_t ambe[9U]; + uint8_t v_ambe[9U]; + uint8_t codec2[8U]; + + ::memset(audio, 0, sizeof(audio)); + ::memset(ambe, 0, sizeof(ambe)); + ::memset(v_ambe, 0, sizeof(v_ambe)); + ::memset(codec2, 0, sizeof(codec2)); + + decode(data, ambe, 0U); + m_mbe->decode_2450(audio, ambe); + m_c2->codec2_encode(codec2, audio); + m_M17.addData(&TAG_DATA, 1U); + m_M17.addData(codec2, 8U); + m_m17N += 1U; + + data += 9U; + for (unsigned int i = 0U; i < 4U; i++) + v_ambe[i] = data[i]; + + v_ambe[4U] = data[4U] & 0xF0; + v_ambe[4U] |= data[10U] & 0x0F; + + for (unsigned int i = 0U; i < 4U; i++) + v_ambe[i + 5U] = data[i + 11U]; + + decode(v_ambe, ambe, 0U); + m_mbe->decode_2450(audio, ambe); + m_c2->codec2_encode(codec2, audio); + m_M17.addData(&TAG_DATA, 1U); + m_M17.addData(codec2, 8U); + m_m17N += 1U; + + data += 15U;; + decode(data, ambe, 0U); + m_mbe->decode_2450(audio, ambe); + m_c2->codec2_encode(codec2, audio); + m_M17.addData(&TAG_DATA, 1U); + m_M17.addData(codec2, 8U); + m_m17N += 1U; +} + +void CModeConv::putM17Header() +{ + unsigned char vch[9U]; + + ::memset(vch, 0, 9U); + + m_DMR.addData(&TAG_HEADER, 1U); + m_DMR.addData(vch, 9U); + m_dmrN += 1U; +} + +void CModeConv::putM17EOT() +{ + unsigned char vch[9U]; + + ::memset(vch, 0, 9U); + + unsigned int fill = 3U - (m_dmrN % 3U); + for (unsigned int i = 0U; i < fill; i++) { + m_DMR.addData(&TAG_DATA, 1U); + m_DMR.addData(AMBE_SILENCE, 9U); + m_dmrN += 1U; + } + + m_DMR.addData(&TAG_EOT, 1U); + m_DMR.addData(vch, 9U); + m_dmrN += 1U; +} + +void CModeConv::putM17(unsigned char* data) +{ + assert(data != NULL); + + int16_t audio[160U]; + int16_t audio_adjusted[160U]; + uint8_t ambe[9U]; + uint8_t codec2[8U]; + uint8_t vch[10U]; + ::memset(audio, 0, sizeof(audio)); + ::memset(ambe, 0, sizeof(ambe)); + + ::memcpy(codec2, &data[36], 8); + m_c2->codec2_decode(audio, codec2); + for(int i = 0; i < 160; ++i){ + m_m17Attenuate ? audio_adjusted[i] = audio[i] / m_m17GainMultiplier : audio[i] * m_m17GainMultiplier; + } + m_mbe->encode_2450(audio_adjusted, ambe); + + encode(ambe, vch, 0U); + m_DMR.addData(&TAG_DATA, 1U); + m_DMR.addData(vch, 9U); + m_dmrN += 1U; + + ::memcpy(codec2, &data[44], 8); + m_c2->codec2_decode(audio, codec2); + for(int i = 0; i < 160; ++i){ + m_m17Attenuate ? audio_adjusted[i] = audio[i] / m_m17GainMultiplier : audio[i] * m_m17GainMultiplier; + } + m_mbe->encode_2450(audio_adjusted, ambe); + + encode(ambe, vch, 0U); + m_DMR.addData(&TAG_DATA, 1U); + m_DMR.addData(vch, 9U); + m_dmrN += 1U; +} + +unsigned int CModeConv::getDMR(unsigned char* data) +{ + unsigned char tmp[9U]; + unsigned char tag[1U]; + + tag[0U] = TAG_NODATA; + + if (m_dmrN >= 1U) { + m_DMR.peek(tag, 1U); + //LogMessage("CModeConv::getDMR %d:%d:%d", m_DMR.isEmpty(), m_dmrN, tag[0]); + if (tag[0U] != TAG_DATA) { + m_DMR.getData(tag, 1U); + m_DMR.getData(data, 9U); + m_dmrN -= 1U; + if(tag[0U] == TAG_EOT){ + m_DMR.clear(); + m_dmrN = 0; + } + return tag[0U]; + } + } + + if (m_dmrN >= 3U) { + m_DMR.getData(tag, 1U); + m_DMR.getData(data, 9U); + m_dmrN -= 1U; + + m_DMR.getData(tag, 1U); + m_DMR.getData(tmp, 9U); + m_dmrN -= 1U; + + ::memcpy(data + 9U, tmp, 4U); + data[13U] = tmp[4U] & 0xF0U; + data[19U] = tmp[4U] & 0x0FU; + ::memcpy(data + 20U, tmp + 5U, 4U); + + m_DMR.getData(tag, 1U); + m_DMR.getData(data + 24U, 9U); + m_dmrN -= 1U; + + return TAG_DATA; + } + else + return TAG_NODATA; +} + +unsigned int CModeConv::getM17(unsigned char* data) +{ + unsigned char tag[2U]; + + tag[0U] = TAG_NODATA; + tag[1U] = TAG_NODATA; + + if (m_m17N >= 2U) { + m_M17.getData(tag, 1U); + m_M17.getData(data, 8U); + m_M17.getData(tag+1, 1U); + m_M17.getData(data+8, 8U); + fprintf(stderr, "getM17() m_m17N:tag1:tag2 == %d:%d:%d\n", m_m17N, tag[0U], tag[1U]); + m_m17N -= 2U; + } + return (tag[1U] == TAG_EOT) ? tag[1U] : tag[0]; +} + +void CModeConv::decode(const unsigned char* in, unsigned char* out, unsigned int offset) const +{ + assert(in != NULL); + assert(out != NULL); + + unsigned int a = 0U; + unsigned int MASK = 0x800000U; + for (unsigned int i = 0U; i < 24U; i++, MASK >>= 1) { + unsigned int aPos = A_TABLE[i]; + if (READ_BIT(in, aPos)) + a |= MASK; + } + + unsigned int b = 0U; + MASK = 0x400000U; + for (unsigned int i = 0U; i < 23U; i++, MASK >>= 1) { + unsigned int bPos = B_TABLE[i]; + if (READ_BIT(in, bPos)) + b |= MASK; + } + + unsigned int c = 0U; + MASK = 0x1000000U; + for (unsigned int i = 0U; i < 25U; i++, MASK >>= 1) { + unsigned int cPos = C_TABLE[i]; + if (READ_BIT(in, cPos)) + c |= MASK; + } + + a >>= 12; + + // The PRNG + b ^= (PRNG_TABLE[a] >> 1); + b >>= 11; + + MASK = 0x000800U; + for (unsigned int i = 0U; i < 12U; i++, MASK >>= 1) { + unsigned int aPos = i + offset + 0U; + unsigned int bPos = i + offset + 12U; + WRITE_BIT(out, aPos, a & MASK); + WRITE_BIT(out, bPos, b & MASK); + } + + MASK = 0x1000000U; + for (unsigned int i = 0U; i < 25U; i++, MASK >>= 1) { + unsigned int cPos = i + offset + 24U; + WRITE_BIT(out, cPos, c & MASK); + } +} + +void CModeConv::encode(const unsigned char* in, unsigned char* out, unsigned int offset) const +{ + assert(in != NULL); + assert(out != NULL); + + unsigned int aOrig = 0U; + unsigned int bOrig = 0U; + unsigned int cOrig = 0U; + + unsigned int MASK = 0x000800U; + for (unsigned int i = 0U; i < 12U; i++, MASK >>= 1) { + unsigned int n1 = i + offset + 0U; + unsigned int n2 = i + offset + 12U; + if (READ_BIT(in, n1)) + aOrig |= MASK; + if (READ_BIT(in, n2)) + bOrig |= MASK; + } + + MASK = 0x1000000U; + for (unsigned int i = 0U; i < 25U; i++, MASK >>= 1) { + unsigned int n = i + offset + 24U; + if (READ_BIT(in, n)) + cOrig |= MASK; + } + + unsigned int a = CGolay24128::encode24128(aOrig); + + // The PRNG + unsigned int p = PRNG_TABLE[aOrig] >> 1; + + unsigned int b = CGolay24128::encode23127(bOrig) >> 1; + b ^= p; + + MASK = 0x800000U; + for (unsigned int i = 0U; i < 24U; i++, MASK >>= 1) { + unsigned int aPos = A_TABLE[i]; + WRITE_BIT(out, aPos, a & MASK); + } + + MASK = 0x400000U; + for (unsigned int i = 0U; i < 23U; i++, MASK >>= 1) { + unsigned int bPos = B_TABLE[i]; + WRITE_BIT(out, bPos, b & MASK); + } + + MASK = 0x1000000U; + for (unsigned int i = 0U; i < 25U; i++, MASK >>= 1) { + unsigned int cPos = C_TABLE[i]; + WRITE_BIT(out, cPos, cOrig & MASK); + } +} diff --git a/DMR2M17/ModeConv.h b/DMR2M17/ModeConv.h new file mode 100644 index 0000000..fcf4151 --- /dev/null +++ b/DMR2M17/ModeConv.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2010,2014,2016,2018 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * Copyright (C) 2020 by Doug McLain AD8DP + * + * 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 "Defines.h" +#include "RingBuffer.h" +#include "MBEVocoder.h" +#include "codec2/codec2.h" + +#if !defined(MODECONV_H) +#define MODECONV_H + +class CModeConv { +public: + CModeConv(); + ~CModeConv(); + + void setM17GainAdjDb(std::string dbstring); + void putDMR(unsigned char* data); + void putDMRHeader(); + void putDMREOT(); + + void putM17(unsigned char* data); + void putM17Header(); + void putM17EOT(); + + unsigned int getM17(unsigned char* data); + unsigned int getDMR(unsigned char* data); + +private: + unsigned int m_m17N; + unsigned int m_dmrN; + CRingBuffer m_M17; + CRingBuffer m_DMR; + MBEVocoder *m_mbe; + CCodec2 *m_c2; + uint16_t m_m17GainMultiplier; + bool m_m17Attenuate; + void encode(const unsigned char* in, unsigned char* out, unsigned int offset) const; + void decode(const unsigned char* in, unsigned char* out, unsigned int offset) const; +}; + +#endif diff --git a/DMR2M17/Mutex.cpp b/DMR2M17/Mutex.cpp new file mode 100644 index 0000000..837e340 --- /dev/null +++ b/DMR2M17/Mutex.cpp @@ -0,0 +1,65 @@ +/* + * 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 "Mutex.h" + +#if defined(_WIN32) || defined(_WIN64) + +CMutex::CMutex() : +m_handle() +{ + m_handle = ::CreateMutex(NULL, FALSE, NULL); +} + +CMutex::~CMutex() +{ + ::CloseHandle(m_handle); +} + +void CMutex::lock() +{ + ::WaitForSingleObject(m_handle, INFINITE); +} + +void CMutex::unlock() +{ + ::ReleaseMutex(m_handle); +} + +#else + +CMutex::CMutex() : +m_mutex(PTHREAD_MUTEX_INITIALIZER) +{ +} + +CMutex::~CMutex() +{ +} + +void CMutex::lock() +{ + ::pthread_mutex_lock(&m_mutex); +} + +void CMutex::unlock() +{ + ::pthread_mutex_unlock(&m_mutex); +} + +#endif diff --git a/DMR2M17/Mutex.h b/DMR2M17/Mutex.h new file mode 100644 index 0000000..7ce9f85 --- /dev/null +++ b/DMR2M17/Mutex.h @@ -0,0 +1,45 @@ +/* + * 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(MUTEX_H) +#define MUTEX_H + +#if defined(_WIN32) || defined(_WIN64) +#include +#else +#include +#endif + +class CMutex +{ +public: + CMutex(); + ~CMutex(); + + void lock(); + void unlock(); + +private: +#if defined(_WIN32) || defined(_WIN64) + HANDLE m_handle; +#else + pthread_mutex_t m_mutex; +#endif +}; + +#endif diff --git a/DMR2M17/QR1676.cpp b/DMR2M17/QR1676.cpp new file mode 100644 index 0000000..1548fc5 --- /dev/null +++ b/DMR2M17/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/DMR2M17/QR1676.h b/DMR2M17/QR1676.h new file mode 100644 index 0000000..dac2c0f --- /dev/null +++ b/DMR2M17/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/DMR2M17/README.md b/DMR2M17/README.md new file mode 100644 index 0000000..e192994 --- /dev/null +++ b/DMR2M17/README.md @@ -0,0 +1,28 @@ +# Description + +This is the source code of DMR2M17, a software for digital voice conversion from DMR to M17 digital mode, based on Jonathan G4KLX's [MMDVM](https://github.com/g4klx) software. Unlike the other cross mode utilities upon which this is based, this utility performs software transcoding between Codec2(M17) and AMBE+2 2450x1150(DMR). + +You can use this software with MMDVMHost with the default UDP ports: + +MMDVMHost(DMR Mode):62032 <-> 62037:DMR2M17:17000 <-> M17Reflector (mrefd) + +This software is licenced under the GPL v2 and is intended for amateur and educational use only. Use of this software for commercial purposes is strictly forbidden. + +# PiStar specific notes + +An entry needs to be added to /root/DMR_Hosts.txt: +``` +DMR2M17 0000 127.0.0.4 none 62037 +``` +And a custom firewall rule needs to be added by creating a file called /root/ipv4.fw and adding the line: +``` +iptables -A OUTPUT -p udp --dport 17000 -j ACCEPT #M17 Outgoing +``` + +# Building + +This utility is not built with the other cross mode ulitities, and has 1 external dependency: + +md380_vocoder https://github.com/nostar/md380_vocoder + +With this dependency installed, run 'make' from the source directory. diff --git a/DMR2M17/RS129.cpp b/DMR2M17/RS129.cpp new file mode 100644 index 0000000..25d66ba --- /dev/null +++ b/DMR2M17/RS129.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 "RS129.h" + +#include +#include +#include + +const unsigned int NPAR = 3U; + +/* 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/DMR2M17/RS129.h b/DMR2M17/RS129.h new file mode 100644 index 0000000..60f99bd --- /dev/null +++ b/DMR2M17/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/DMR2M17/RingBuffer.h b/DMR2M17/RingBuffer.h new file mode 100644 index 0000000..707de1c --- /dev/null +++ b/DMR2M17/RingBuffer.h @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2006-2009,2012,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 RingBuffer_H +#define RingBuffer_H + +#include "Log.h" + +#include +#include +#include + +template class CRingBuffer { +public: + CRingBuffer(unsigned int length, const char* name) : + m_length(length), + m_name(name), + m_buffer(NULL), + m_iPtr(0U), + m_oPtr(0U) + { + assert(length > 0U); + assert(name != NULL); + + m_buffer = new T[length]; + + ::memset(m_buffer, 0x00, m_length * sizeof(T)); + } + + ~CRingBuffer() + { + delete[] m_buffer; + } + + bool addData(const T* buffer, unsigned int nSamples) + { + if (nSamples >= freeSpace()) { + LogError("%s buffer overflow, clearing the buffer. (%u >= %u)", m_name, nSamples, freeSpace()); + clear(); + return false; + } + + for (unsigned int i = 0U; i < nSamples; i++) { + m_buffer[m_iPtr++] = buffer[i]; + + if (m_iPtr == m_length) + m_iPtr = 0U; + } + + return true; + } + + bool getData(T* buffer, unsigned int nSamples) + { + if (dataSize() < nSamples) { + LogError("**** Underflow in %s ring buffer, %u < %u", m_name, dataSize(), nSamples); + return false; + } + + for (unsigned int i = 0U; i < nSamples; i++) { + buffer[i] = m_buffer[m_oPtr++]; + + if (m_oPtr == m_length) + m_oPtr = 0U; + } + + return true; + } + + bool peek(T* buffer, unsigned int nSamples) + { + if (dataSize() < nSamples) { + LogError("**** Underflow peek in %s ring buffer, %u < %u", m_name, dataSize(), nSamples); + return false; + } + + 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 true; + } + + void clear() + { + m_iPtr = 0U; + m_oPtr = 0U; + + ::memset(m_buffer, 0x00, m_length * sizeof(T)); + } + + unsigned int freeSpace() const + { + unsigned int len = m_length; + + if (m_oPtr > m_iPtr) + len = m_oPtr - m_iPtr; + else if (m_iPtr > m_oPtr) + len = m_length - (m_iPtr - m_oPtr); + + if (len > m_length) + len = 0U; + + return len; + } + + unsigned int dataSize() const + { + return m_length - freeSpace(); + } + + 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; + const char* m_name; + T* m_buffer; + unsigned int m_iPtr; + unsigned int m_oPtr; +}; + +#endif diff --git a/DMR2M17/SHA256.cpp b/DMR2M17/SHA256.cpp new file mode 100644 index 0000000..b3366e0 --- /dev/null +++ b/DMR2M17/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/DMR2M17/SHA256.h b/DMR2M17/SHA256.h new file mode 100644 index 0000000..7c48f19 --- /dev/null +++ b/DMR2M17/SHA256.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc. + * Copyright (C) 2011,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 SHA256_H +#define SHA256_H + +#include + +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/DMR2M17/StopWatch.cpp b/DMR2M17/StopWatch.cpp new file mode 100644 index 0000000..481241b --- /dev/null +++ b/DMR2M17/StopWatch.cpp @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2015,2016,2018 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_frequencyS(), +m_frequencyMS(), +m_start() +{ + ::QueryPerformanceFrequency(&m_frequencyS); + + m_frequencyMS.QuadPart = m_frequencyS.QuadPart / 1000ULL; +} + +CStopWatch::~CStopWatch() +{ +} + +unsigned long long CStopWatch::time() const +{ + LARGE_INTEGER now; + ::QueryPerformanceCounter(&now); + + return (unsigned long long)(now.QuadPart / m_frequencyMS.QuadPart); +} + +unsigned long long CStopWatch::start() +{ + ::QueryPerformanceCounter(&m_start); + + return (unsigned long long)(m_start.QuadPart / m_frequencyS.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_frequencyS.QuadPart); +} + +#else + +#include +#include + +CStopWatch::CStopWatch() : +m_startMS(0ULL) +{ +} + +CStopWatch::~CStopWatch() +{ +} + +unsigned long long CStopWatch::time() const +{ + struct timeval now; + ::gettimeofday(&now, NULL); + + return now.tv_sec * 1000ULL + now.tv_usec / 1000ULL; +} + +unsigned long long CStopWatch::start() +{ + struct timespec now; + ::clock_gettime(CLOCK_MONOTONIC, &now); + + m_startMS = now.tv_sec * 1000ULL + now.tv_nsec / 1000000ULL; + + return m_startMS; +} + +unsigned int CStopWatch::elapsed() +{ + struct timespec now; + ::clock_gettime(CLOCK_MONOTONIC, &now); + + unsigned long long nowMS = now.tv_sec * 1000ULL + now.tv_nsec / 1000000ULL; + + return nowMS - m_startMS; +} + +#endif diff --git a/DMR2M17/StopWatch.h b/DMR2M17/StopWatch.h new file mode 100644 index 0000000..3f8fa19 --- /dev/null +++ b/DMR2M17/StopWatch.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2015,2016,2018 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 long time() const; + + unsigned long long start(); + unsigned int elapsed(); + +private: +#if defined(_WIN32) || defined(_WIN64) + LARGE_INTEGER m_frequencyS; + LARGE_INTEGER m_frequencyMS; + LARGE_INTEGER m_start; +#else + unsigned long long m_startMS; +#endif +}; + +#endif diff --git a/DMR2M17/Sync.cpp b/DMR2M17/Sync.cpp new file mode 100644 index 0000000..a6f1fb8 --- /dev/null +++ b/DMR2M17/Sync.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 "Sync.h" + +#include "DMRDefines.h" + +#include +#include +#include + +void CSync::addDMRDataSync(unsigned char* data, bool duplex) +{ + assert(data != NULL); + + if (duplex) { + for (unsigned int i = 0U; i < 7U; i++) + data[i + 13U] = (data[i + 13U] & ~SYNC_MASK[i]) | BS_SOURCED_DATA_SYNC[i]; + } else { + for (unsigned int i = 0U; i < 7U; i++) + data[i + 13U] = (data[i + 13U] & ~SYNC_MASK[i]) | MS_SOURCED_DATA_SYNC[i]; + } +} + +void CSync::addDMRAudioSync(unsigned char* data, bool duplex) +{ + assert(data != NULL); + + if (duplex) { + for (unsigned int i = 0U; i < 7U; i++) + data[i + 13U] = (data[i + 13U] & ~SYNC_MASK[i]) | BS_SOURCED_AUDIO_SYNC[i]; + } else { + for (unsigned int i = 0U; i < 7U; i++) + data[i + 13U] = (data[i + 13U] & ~SYNC_MASK[i]) | MS_SOURCED_AUDIO_SYNC[i]; + } +} + diff --git a/DMR2M17/Sync.h b/DMR2M17/Sync.h new file mode 100644 index 0000000..8117335 --- /dev/null +++ b/DMR2M17/Sync.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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(SYNC_H) +#define SYNC_H + +class CSync +{ +public: + static void addDMRDataSync(unsigned char* data, bool duplex); + static void addDMRAudioSync(unsigned char* data, bool duplex); + +private: +}; + +#endif diff --git a/DMR2M17/Thread.cpp b/DMR2M17/Thread.cpp new file mode 100644 index 0000000..b334436 --- /dev/null +++ b/DMR2M17/Thread.cpp @@ -0,0 +1,101 @@ +/* + * 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 "Thread.h" + +#if defined(_WIN32) || defined(_WIN64) + +CThread::CThread() : +m_handle() +{ +} + +CThread::~CThread() +{ +} + +bool CThread::run() +{ + m_handle = ::CreateThread(NULL, 0, &helper, this, 0, NULL); + + return m_handle != NULL; +} + + +void CThread::wait() +{ + ::WaitForSingleObject(m_handle, INFINITE); + + ::CloseHandle(m_handle); +} + + +DWORD CThread::helper(LPVOID arg) +{ + CThread* p = (CThread*)arg; + + p->entry(); + + return 0UL; +} + +void CThread::sleep(unsigned int ms) +{ + ::Sleep(ms); +} + +#else + +#include + +CThread::CThread() : +m_thread() +{ +} + +CThread::~CThread() +{ +} + +bool CThread::run() +{ + return ::pthread_create(&m_thread, NULL, helper, this) == 0; +} + + +void CThread::wait() +{ + ::pthread_join(m_thread, NULL); +} + + +void* CThread::helper(void* arg) +{ + CThread* p = (CThread*)arg; + + p->entry(); + + return NULL; +} + +void CThread::sleep(unsigned int ms) +{ + ::usleep(ms * 1000); +} + +#endif diff --git a/DMR2M17/Thread.h b/DMR2M17/Thread.h new file mode 100644 index 0000000..352d938 --- /dev/null +++ b/DMR2M17/Thread.h @@ -0,0 +1,56 @@ +/* + * 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(THREAD_H) +#define THREAD_H + +#if defined(_WIN32) || defined(_WIN64) +#include +#else +#include +#endif + +class CThread +{ +public: + CThread(); + virtual ~CThread(); + + virtual bool run(); + + virtual void entry() = 0; + + virtual void wait(); + + static void sleep(unsigned int ms); + +private: +#if defined(_WIN32) || defined(_WIN64) + HANDLE m_handle; +#else + pthread_t m_thread; +#endif + +#if defined(_WIN32) || defined(_WIN64) + static DWORD __stdcall helper(LPVOID arg); +#else + static void* helper(void* arg); +#endif +}; + +#endif diff --git a/DMR2M17/Timer.cpp b/DMR2M17/Timer.cpp new file mode 100644 index 0000000..53956e4 --- /dev/null +++ b/DMR2M17/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/DMR2M17/Timer.h b/DMR2M17/Timer.h new file mode 100644 index 0000000..87d68f5 --- /dev/null +++ b/DMR2M17/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/DMR2M17/UDPSocket.cpp b/DMR2M17/UDPSocket.cpp new file mode 100644 index 0000000..8d88c62 --- /dev/null +++ b/DMR2M17/UDPSocket.cpp @@ -0,0 +1,212 @@ +/* + * 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 +#include +#include + + +CUDPSocket::CUDPSocket(const std::string& address, unsigned int port) : +m_address(address), +m_port(port), +m_fd(-1) +{ + assert(!address.empty()); +} + +CUDPSocket::CUDPSocket(unsigned int port) : +m_address(), +m_port(port), +m_fd(-1) +{ + +} + +CUDPSocket::~CUDPSocket() +{ + +} + +in_addr CUDPSocket::lookup(const std::string& hostname) +{ + in_addr addr; + + in_addr_t address = ::inet_addr(hostname.c_str()); + if (address != in_addr_t(-1)) { + addr.s_addr = address; + LogInfo("inet_addr() returns %x", addr.s_addr); + return addr; + } + + struct hostent* hp = ::gethostbyname(hostname.c_str()); + if (hp != NULL) { + ::memcpy(&addr, hp->h_addr_list[0], sizeof(struct in_addr)); + LogInfo("gethostbyname() returns %x", addr.s_addr); + return addr; + } + + LogError("Cannot find address for host %s", hostname.c_str()); + + addr.s_addr = INADDR_NONE; + return addr; +} + +bool CUDPSocket::open() +{ + m_fd = ::socket(AF_INET, SOCK_DGRAM, 0); + if (m_fd < 0) { + + LogError("Cannot create the UDP socket, err: %d", errno); + 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()) { + + addr.sin_addr.s_addr = ::inet_addr(m_address.c_str()); + + 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) { + + LogError("Cannot set the UDP socket option, err: %d", errno); + + return false; + } + + if (::bind(m_fd, (sockaddr*)&addr, sizeof(sockaddr_in)) == -1) { + + LogError("Cannot bind the UDP address, err: %d", errno); + + 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); + + + ssize_t ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&addr, sizeof(sockaddr_in)); + + if (ret < 0) { + + LogError("Error returned from sendto, err: %d", errno); + + return false; + } + + + if (ret != ssize_t(length)) + return false; + + + return true; +} + +void CUDPSocket::close() +{ +#if defined(_WIN32) || defined(_WIN64) + ::closesocket(m_fd); +#else + ::close(m_fd); +#endif +} diff --git a/DMR2M17/UDPSocket.h b/DMR2M17/UDPSocket.h new file mode 100644 index 0000000..c68c11e --- /dev/null +++ b/DMR2M17/UDPSocket.h @@ -0,0 +1,54 @@ +/* + * 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 + +#include +#include +#include +#include +#include +#include +#include +#include + +class CUDPSocket { +public: + CUDPSocket(const std::string& address, unsigned int port = 0U); + CUDPSocket(unsigned int port = 0U); + ~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/DMR2M17/Utils.cpp b/DMR2M17/Utils.cpp new file mode 100644 index 0000000..49ded13 --- /dev/null +++ b/DMR2M17/Utils.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2009,2014,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 "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) +{ + assert(bits != NULL); + + 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) +{ + assert(bits != NULL); + + 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) +{ + assert(bits != NULL); + + 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) +{ + assert(bits != NULL); + + 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/DMR2M17/Utils.h b/DMR2M17/Utils.h new file mode 100644 index 0000000..ade28c0 --- /dev/null +++ b/DMR2M17/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/DMR2M17/Version.h b/DMR2M17/Version.h new file mode 100644 index 0000000..759c9f0 --- /dev/null +++ b/DMR2M17/Version.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 = "20200621"; + +#endif diff --git a/DMR2M17/codec2/codebooks.cpp b/DMR2M17/codec2/codebooks.cpp new file mode 100644 index 0000000..bf319ce --- /dev/null +++ b/DMR2M17/codec2/codebooks.cpp @@ -0,0 +1,964 @@ +/* + * This intermediary file and the files that used to create it are under + * The LGPL. See the file COPYING. + */ + +#include "defines.h" + +/* codebook/lsp1.txt */ +static float codes00[] = +{ + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600 +}; +/* codebook/lsp2.txt */ +static float codes01[] = +{ + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700 +}; +/* codebook/lsp3.txt */ +static float codes02[] = +{ + 500, + 550, + 600, + 650, + 700, + 750, + 800, + 850, + 900, + 950, + 1000, + 1050, + 1100, + 1150, + 1200, + 1250 +}; +/* codebook/lsp4.txt */ +static float codes03[] = +{ + 700, + 800, + 900, + 1000, + 1100, + 1200, + 1300, + 1400, + 1500, + 1600, + 1700, + 1800, + 1900, + 2000, + 2100, + 2200 +}; +/* codebook/lsp5.txt */ +static float codes04[] = +{ + 950, + 1050, + 1150, + 1250, + 1350, + 1450, + 1550, + 1650, + 1750, + 1850, + 1950, + 2050, + 2150, + 2250, + 2350, + 2450 +}; +/* codebook/lsp6.txt */ +static float codes05[] = +{ + 1100, + 1200, + 1300, + 1400, + 1500, + 1600, + 1700, + 1800, + 1900, + 2000, + 2100, + 2200, + 2300, + 2400, + 2500, + 2600 +}; +/* codebook/lsp7.txt */ +static float codes06[] = +{ + 1500, + 1600, + 1700, + 1800, + 1900, + 2000, + 2100, + 2200, + 2300, + 2400, + 2500, + 2600, + 2700, + 2800, + 2900, + 3000 +}; +/* codebook/lsp8.txt */ +static float codes07[] = +{ + 2300, + 2400, + 2500, + 2600, + 2700, + 2800, + 2900, + 3000 +}; +/* codebook/lsp9.txt */ +static float codes08[] = +{ + 2500, + 2600, + 2700, + 2800, + 2900, + 3000, + 3100, + 3200 +}; +/* codebook/lsp10.txt */ +static float codes09[] = +{ + 2900, + 3100, + 3300, + 3500 +}; + +const struct lsp_codebook lsp_cb[] = +{ + /* codebook/lsp1.txt */ + { + 1, + 4, + 16, + codes00 + }, + /* codebook/lsp2.txt */ + { + 1, + 4, + 16, + codes01 + }, + /* codebook/lsp3.txt */ + { + 1, + 4, + 16, + codes02 + }, + /* codebook/lsp4.txt */ + { + 1, + 4, + 16, + codes03 + }, + /* codebook/lsp5.txt */ + { + 1, + 4, + 16, + codes04 + }, + /* codebook/lsp6.txt */ + { + 1, + 4, + 16, + codes05 + }, + /* codebook/lsp7.txt */ + { + 1, + 4, + 16, + codes06 + }, + /* codebook/lsp8.txt */ + { + 1, + 3, + 8, + codes07 + }, + /* codebook/lsp9.txt */ + { + 1, + 3, + 8, + codes08 + }, + /* codebook/lsp10.txt */ + { + 1, + 2, + 4, + codes09 + }, + { 0, 0, 0, 0 } +}; + +/* codebook/dlsp1.txt */ +static float codes10[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; +/* codebook/dlsp2.txt */ +static float codes11[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; +/* codebook/dlsp3.txt */ +static float codes12[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; +/* codebook/dlsp4.txt */ +static float codes13[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 250, + 300, + 350, + 400, + 450, + 500, + 550, + 600, + 650, + 700, + 750, + 800, + 850, + 900, + 950, + 1000, + 1050, + 1100, + 1150, + 1200, + 1250, + 1300, + 1350, + 1400 +}; +/* codebook/dlsp5.txt */ +static float codes14[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 250, + 300, + 350, + 400, + 450, + 500, + 550, + 600, + 650, + 700, + 750, + 800, + 850, + 900, + 950, + 1000, + 1050, + 1100, + 1150, + 1200, + 1250, + 1300, + 1350, + 1400 +}; +/* codebook/dlsp6.txt */ +static float codes15[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 250, + 300, + 350, + 400, + 450, + 500, + 550, + 600, + 650, + 700, + 750, + 800, + 850, + 900, + 950, + 1000, + 1050, + 1100, + 1150, + 1200, + 1250, + 1300, + 1350, + 1400 +}; +/* codebook/dlsp7.txt */ +static float codes16[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; +/* codebook/dlsp8.txt */ +static float codes17[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; +/* codebook/dlsp9.txt */ +static float codes18[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; +/* codebook/dlsp10.txt */ +static float codes19[] = +{ + 25, + 50, + 75, + 100, + 125, + 150, + 175, + 200, + 225, + 250, + 275, + 300, + 325, + 350, + 375, + 400, + 425, + 450, + 475, + 500, + 525, + 550, + 575, + 600, + 625, + 650, + 675, + 700, + 725, + 750, + 775, + 800 +}; + +const struct lsp_codebook lsp_cbd[] = +{ + /* codebook/dlsp1.txt */ + { + 1, + 5, + 32, + codes10 + }, + /* codebook/dlsp2.txt */ + { + 1, + 5, + 32, + codes11 + }, + /* codebook/dlsp3.txt */ + { + 1, + 5, + 32, + codes12 + }, + /* codebook/dlsp4.txt */ + { + 1, + 5, + 32, + codes13 + }, + /* codebook/dlsp5.txt */ + { + 1, + 5, + 32, + codes14 + }, + /* codebook/dlsp6.txt */ + { + 1, + 5, + 32, + codes15 + }, + /* codebook/dlsp7.txt */ + { + 1, + 5, + 32, + codes16 + }, + /* codebook/dlsp8.txt */ + { + 1, + 5, + 32, + codes17 + }, + /* codebook/dlsp9.txt */ + { + 1, + 5, + 32, + codes18 + }, + /* codebook/dlsp10.txt */ + { + 1, + 5, + 32, + codes19 + }, + { 0, 0, 0, 0 } +}; + + +/* codebook/gecb.txt */ +static float codes30[] = +{ + 2.71, 12.0184, + 0.04675, -2.73881, + 0.120993, 8.38895, + -1.58028, -0.892307, + 1.19307, -1.91561, + 0.187101, -3.27679, + 0.332251, -7.66455, + -1.47944, 31.2461, + 1.52761, 27.7095, + -0.524379, 5.25012, + 0.55333, 7.4388, + -0.843451, -1.95299, + 2.26389, 8.61029, + 0.143143, 2.36549, + 0.616506, 1.28427, + -1.71133, 22.0967, + 1.00813, 17.3965, + -0.106718, 1.41891, + -0.136246, 14.2736, + -1.70909, -20.5319, + 1.65787, -3.39107, + 0.138049, -4.95785, + 0.536729, -1.94375, + 0.196307, 36.8519, + 1.27248, 22.5565, + -0.670219, -1.90604, + 0.382092, 6.40113, + -0.756911, -4.90102, + 1.82931, 4.6138, + 0.318794, 0.73683, + 0.612815, -2.07505, + -0.410151, 24.7871, + 1.77602, 13.1909, + 0.106457, -0.104492, + 0.192206, 10.1838, + -1.82442, -7.71565, + 0.931346, 4.34835, + 0.308813, -4.086, + 0.397143, -11.8089, + -0.048715, 41.2273, + 0.877342, 35.8503, + -0.759794, 0.476634, + 0.978593, 7.67467, + -1.19506, 3.03883, + 2.63989, -3.41106, + 0.191127, 3.60351, + 0.402932, 1.0843, + -2.15202, 18.1076, + 1.5468, 8.32271, + -0.143089, -4.07592, + -0.150142, 5.86674, + -1.40844, -3.2507, + 1.56615, -10.4132, + 0.178171, -10.2267, + 0.362164, -0.028556, + -0.070125, 24.3907, + 0.594752, 17.4828, + -0.28698, -6.90407, + 0.464818, 10.2055, + -1.00684, -14.3572, + 2.32957, -3.69161, + 0.335745, 2.40714, + 1.01966, -3.15565, + -1.25945, 7.9919, + 2.38369, 19.6806, + -0.094947, -2.41374, + 0.20933, 6.66477, + -2.22103, 1.37986, + 1.29239, 2.04633, + 0.243626, -0.890741, + 0.428773, -7.19366, + -1.11374, 41.3414, + 2.6098, 31.1405, + -0.446468, 2.53419, + 0.490104, 4.62757, + -1.11723, -3.24174, + 1.79156, 8.41493, + 0.156012, 0.183336, + 0.532447, 3.15455, + -0.764484, 18.514, + 0.952395, 11.7713, + -0.332567, 0.346987, + 0.202165, 14.7168, + -2.12924, -15.559, + 1.35358, -1.92679, + -0.010963, -16.3364, + 0.399053, -2.79057, + 0.750657, 31.1483, + 0.655743, 24.4819, + -0.45321, -0.735879, + 0.2869, 6.5467, + -0.715673, -12.3578, + 1.54849, 3.87217, + 0.271874, 0.802339, + 0.502073, -4.85485, + -0.497037, 17.7619, + 1.19116, 13.9544, + 0.01563, 1.33157, + 0.341867, 8.93537, + -2.31601, -5.39506, + 0.75861, 1.9645, + 0.24132, -3.23769, + 0.267151, -11.2344, + -0.273126, 32.6248, + 1.75352, 40.432, + -0.784011, 3.04576, + 0.705987, 5.66118, + -1.3864, 1.35356, + 2.37646, 1.67485, + 0.242973, 4.73218, + 0.491227, 0.354061, + -1.60676, 8.65895, + 1.16711, 5.9871, + -0.137601, -12.0417, + -0.251375, 10.3972, + -1.43151, -8.90411, + 0.98828, -13.209, + 0.261484, -6.35497, + 0.395932, -0.702529, + 0.283704, 26.8996, + 0.420959, 15.4418, + -0.355804, -13.7278, + 0.527372, 12.3985, + -1.16956, -15.9985, + 1.90669, -5.81605, + 0.354492, 3.85157, + 0.82576, -4.16264, + -0.49019, 13.0572, + 2.25577, 13.5264, + -0.004956, -3.23713, + 0.026709, 7.86645, + -1.81037, -0.451183, + 1.08383, -0.18362, + 0.135836, -2.26658, + 0.375812, -5.51225, + -1.96644, 38.6829, + 1.97799, 24.5655, + -0.704656, 6.35881, + 0.480786, 7.05175, + -0.976417, -2.42273, + 2.50215, 6.75935, + 0.083588, 3.2588, + 0.543629, 0.910013, + -1.23196, 23.0915, + 0.785492, 14.807, + -0.213554, 1.688, + 0.004748, 18.1718, + -1.54719, -16.1168, + 1.50104, -3.28114, + 0.080133, -4.63472, + 0.476592, -2.18093, + 0.44247, 40.304, + 1.07277, 27.592, + -0.594738, -4.16681, + 0.42248, 7.61609, + -0.927521, -7.27441, + 1.99162, 1.29636, + 0.291307, 2.39878, + 0.721081, -1.95062, + -0.804256, 24.9295, + 1.64839, 19.1197, + 0.060852, -0.590639, + 0.266085, 9.10325, + -1.9574, -2.88461, + 1.11693, 2.6724, + 0.35458, -2.74854, + 0.330733, -14.1561, + -0.527851, 39.5756, + 0.991152, 43.195, + -0.589619, 1.26919, + 0.787401, 8.73071, + -1.0138, 1.02507, + 2.8254, 1.89538, + 0.24089, 2.74557, + 0.427195, 2.54446, + -1.95311, 12.244, + 1.44862, 12.0607, + -0.210492, -3.37906, + -0.056713, 10.204, + -1.65237, -5.10274, + 1.29475, -12.2708, + 0.111608, -8.67592, + 0.326634, -1.16763, + 0.021781, 31.1258, + 0.455335, 21.4684, + -0.37544, -3.37121, + 0.39362, 11.302, + -0.851456, -19.4149, + 2.10703, -2.22886, + 0.373233, 1.92406, + 0.884438, -1.72058, + -0.975127, 9.84013, + 2.0033, 17.3954, + -0.036915, -1.11137, + 0.148456, 5.39997, + -1.91441, 4.77382, + 1.44791, 0.537122, + 0.194979, -1.03818, + 0.495771, -9.95502, + -1.05899, 32.9471, + 2.01122, 32.4544, + -0.30965, 4.71911, + 0.436082, 4.63552, + -1.23711, -1.25428, + 2.02274, 9.42834, + 0.190342, 1.46077, + 0.479017, 2.48479, + -1.07848, 16.2217, + 1.20764, 9.65421, + -0.258087, -1.67236, + 0.071852, 13.416, + -1.87723, -16.072, + 1.28957, -4.87118, + 0.067713, -13.4427, + 0.435551, -4.1655, + 0.46614, 30.5895, + 0.904895, 21.598, + -0.518369, -2.53205, + 0.337363, 5.63726, + -0.554975, -17.4005, + 1.69188, 1.14574, + 0.227934, 0.889297, + 0.587303, -5.72973, + -0.262133, 18.6666, + 1.39505, 17.0029, + -0.01909, 4.30838, + 0.304235, 12.6699, + -2.07406, -6.46084, + 0.920546, 1.21296, + 0.284927, -1.78547, + 0.209724, -16.024, + -0.636067, 31.5768, + 1.34989, 34.6775, + -0.971625, 5.30086, + 0.590249, 4.44971, + -1.56787, 3.60239, + 2.1455, 4.51666, + 0.296022, 4.12017, + 0.445299, 0.868772, + -1.44193, 14.1284, + 1.35575, 6.0074, + -0.012814, -7.49657, + -0.43, 8.50012, + -1.20469, -7.11326, + 1.10102, -6.83682, + 0.196463, -6.234, + 0.436747, -1.12979, + 0.141052, 22.8549, + 0.290821, 18.8114, + -0.529536, -7.73251, + 0.63428, 10.7898, + -1.33472, -20.3258, + 1.81564, -1.90332, + 0.394778, 3.79758, + 0.732682, -8.18382, + -0.741244, 11.7683 +}; + +const struct lsp_codebook ge_cb[] = +{ + /* codebook/gecb.txt */ + { + 2, + 8, + 256, + codes30 + }, + { 0, 0, 0, 0 } +}; diff --git a/DMR2M17/codec2/codec2.cpp b/DMR2M17/codec2/codec2.cpp new file mode 100644 index 0000000..9418633 --- /dev/null +++ b/DMR2M17/codec2/codec2.cpp @@ -0,0 +1,1745 @@ +/*---------------------------------------------------------------------------*\ + + FILE........: codec2.c + AUTHOR......: David Rowe + DATE CREATED: 21/8/2010 + + Codec2 fully quantised encoder and decoder functions. If you want use + codec2, the codec2_xxx functions are for you. + +\*---------------------------------------------------------------------------*/ + +/* + Copyright (C) 2010 David Rowe + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#include +#include +#include +#include +#include +#include + +#include "nlp.h" +#include "lpc.h" +#include "quantise.h" +#include "codec2.h" +#include "codec2_internal.h" + +#define HPF_BETA 0.125 +#define BPF_N 101 + +CKissFFT kiss; + +/*---------------------------------------------------------------------------* \ + + FUNCTION HEADERS + +\*---------------------------------------------------------------------------*/ + + + + +/*---------------------------------------------------------------------------*\ + + FUNCTIONS + +\*---------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: codec2_create + AUTHOR......: David Rowe + DATE CREATED: 21/8/2010 + + Create and initialise an instance of the codec. Returns a pointer + to the codec states or NULL on failure. One set of states is + sufficient for a full duuplex codec (i.e. an encoder and decoder). + You don't need separate states for encoders and decoders. See + c2enc.c and c2dec.c for examples. + +\*---------------------------------------------------------------------------*/ + +CCodec2::CCodec2(bool is_3200) +{ + c2.mode = is_3200 ? 3200 : 1600; + + /* store constants in a few places for convenience */ + + c2.c2const = c2const_create(8000, N_S); + c2.Fs = c2.c2const.Fs; + int n_samp = c2.n_samp = c2.c2const.n_samp; + int m_pitch = c2.m_pitch = c2.c2const.m_pitch; + + c2.Pn.resize(2*n_samp); + c2.Sn_.resize(2*n_samp); + c2.w.resize(m_pitch); + c2.Sn.resize(m_pitch); + + for(int i=0; i Aw[FFT_ENC]; + + /* only need to zero these out due to (unused) snr calculation */ + + for(i=0; i<2; i++) + for(j=1; j<=MAX_AMP; j++) + model[i].A[j] = 0.0; + + /* unpack bits from channel ------------------------------------*/ + + /* this will partially fill the model params for the 2 x 10ms + frames */ + + model[0].voiced = qt.unpack(bits, &nbit, 1); + model[1].voiced = qt.unpack(bits, &nbit, 1); + + Wo_index = qt.unpack(bits, &nbit, WO_BITS); + model[1].Wo = qt.decode_Wo(&c2.c2const, Wo_index, WO_BITS); + model[1].L = PI/model[1].Wo; + + e_index = qt.unpack(bits, &nbit, E_BITS); + e[1] = qt.decode_energy(e_index, E_BITS); + + for(i=0; i Aw[FFT_ENC]; + + /* only need to zero these out due to (unused) snr calculation */ + + for(i=0; i<4; i++) + for(j=1; j<=MAX_AMP; j++) + model[i].A[j] = 0.0; + + /* unpack bits from channel ------------------------------------*/ + + /* this will partially fill the model params for the 4 x 10ms + frames */ + + model[0].voiced = qt.unpack(bits, &nbit, 1); + + model[1].voiced = qt.unpack(bits, &nbit, 1); + Wo_index = qt.unpack(bits, &nbit, WO_BITS); + model[1].Wo = qt.decode_Wo(&c2.c2const, Wo_index, WO_BITS); + model[1].L = PI/model[1].Wo; + + e_index = qt.unpack(bits, &nbit, E_BITS); + e[1] = qt.decode_energy(e_index, E_BITS); + + model[2].voiced = qt.unpack(bits, &nbit, 1); + + model[3].voiced = qt.unpack(bits, &nbit, 1); + Wo_index = qt.unpack(bits, &nbit, WO_BITS); + model[3].Wo = qt.decode_Wo(&c2.c2const, Wo_index, WO_BITS); + model[3].L = PI/model[3].Wo; + + e_index = qt.unpack(bits, &nbit, E_BITS); + e[3] = qt.decode_energy(e_index, E_BITS); + + for(i=0; i Aw[], float gain) +{ + int i; + + /* LPC based phase synthesis */ + std::complex H[MAX_AMP+1]; + sample_phase(model, H, Aw); + phase_synth_zero_order(c2.n_samp, model, &c2.ex_phase, H); + + postfilter(model, &c2.bg_est); + synthesise(c2.n_samp, &(c2.fftr_inv_cfg), c2.Sn_.data(), model, c2.Pn.data(), 1); + + for(i=0; i 32767.0) + speech[i] = 32767; + else if (c2.Sn_[i] < -32767.0) + speech[i] = -32767; + else + speech[i] = c2.Sn_[i]; + } + +} + + +/*---------------------------------------------------------------------------* \ + + FUNCTION....: analyse_one_frame() + AUTHOR......: David Rowe + DATE CREATED: 23/8/2010 + + Extract sinusoidal model parameters from 80 speech samples (10ms of + speech). + +\*---------------------------------------------------------------------------*/ + +void CCodec2::analyse_one_frame(MODEL *model, const short *speech) +{ + std::complex Sw[FFT_ENC]; + float pitch; + int i; + int n_samp = c2.n_samp; + int m_pitch = c2.m_pitch; + + /* Read input speech */ + + for(i=0; iWo = TWO_PI/pitch; + model->L = PI/model->Wo; + + /* estimate model parameters */ + two_stage_pitch_refinement(&c2.c2const, model, Sw); + + /* estimate phases when doing ML experiments */ + estimate_amplitudes(model, Sw, 0); + est_voicing_mbe(&c2.c2const, model, Sw, c2.W); +} + + +/*---------------------------------------------------------------------------* \ + + FUNCTION....: ear_protection() + AUTHOR......: David Rowe + DATE CREATED: Nov 7 2012 + + Limits output level to protect ears when there are bit errors or the input + is overdriven. This doesn't correct or mask bit errors, just reduces the + worst of their damage. + +\*---------------------------------------------------------------------------*/ + +void CCodec2::ear_protection(float in_out[], int n) +{ + float max_sample, over, gain; + int i; + + /* find maximum sample in frame */ + + max_sample = 0.0; + for(i=0; i max_sample) + max_sample = in_out[i]; + + /* determine how far above set point */ + + over = max_sample/30000.0; + + /* If we are x dB over set point we reduce level by 2x dB, this + attenuates major excursions in amplitude (likely to be caused + by bit errors) more than smaller ones */ + + if (over > 1.0) + { + gain = 1.0/(over*over); + for(i=0; i H[], + std::complex A[] /* LPC analysis filter in freq domain */ +) +{ + int m, b; + float r; + + r = TWO_PI/(FFT_ENC); + + /* Sample phase at harmonics */ + + for(m=1; m<=model->L; m++) + { + b = (int)(m*model->Wo/r + 0.5); + H[m] = std::conj(A[b]); + } +} + + +/*---------------------------------------------------------------------------*\ + + phase_synth_zero_order() + + Synthesises phases based on SNR and a rule based approach. No phase + parameters are required apart from the SNR (which can be reduced to a + 1 bit V/UV decision per frame). + + The phase of each harmonic is modelled as the phase of a synthesis + filter excited by an impulse. In many Codec 2 modes the synthesis + filter is a LPC filter. Unlike the first order model the position + of the impulse is not transmitted, so we create an excitation pulse + train using a rule based approach. + + Consider a pulse train with a pulse starting time n=0, with pulses + repeated at a rate of Wo, the fundamental frequency. A pulse train + in the time domain is equivalent to harmonics in the frequency + domain. We can make an excitation pulse train using a sum of + sinsusoids: + + for(m=1; m<=L; m++) + ex[n] = cos(m*Wo*n) + + Note: the Octave script ../octave/phase.m is an example of this if + you would like to try making a pulse train. + + The phase of each excitation harmonic is: + + arg(E[m]) = mWo + + where E[m] are the complex excitation (freq domain) samples, + arg(x), just returns the phase of a complex sample x. + + As we don't transmit the pulse position for this model, we need to + synthesise it. Now the excitation pulses occur at a rate of Wo. + This means the phase of the first harmonic advances by N_SAMP samples + over a synthesis frame of N_SAMP samples. For example if Wo is pi/20 + (200 Hz), then over a 10ms frame (N_SAMP=80 samples), the phase of the + first harmonic would advance (pi/20)*80 = 4*pi or two complete + cycles. + + We generate the excitation phase of the fundamental (first + harmonic): + + arg[E[1]] = Wo*N_SAMP; + + We then relate the phase of the m-th excitation harmonic to the + phase of the fundamental as: + + arg(E[m]) = m*arg(E[1]) + + This E[m] then gets passed through the LPC synthesis filter to + determine the final harmonic phase. + + Comparing to speech synthesised using original phases: + + - Through headphones speech synthesised with this model is not as + good. Through a loudspeaker it is very close to original phases. + + - If there are voicing errors, the speech can sound clicky or + staticy. If V speech is mistakenly declared UV, this model tends to + synthesise impulses or clicks, as there is usually very little shift or + dispersion through the LPC synthesis filter. + + - When combined with LPC amplitude modelling there is an additional + drop in quality. I am not sure why, theory is interformant energy + is raised making any phase errors more obvious. + + NOTES: + + 1/ This synthesis model is effectively the same as a simple LPC-10 + vocoders, and yet sounds much better. Why? Conventional wisdom + (AMBE, MELP) says mixed voicing is required for high quality + speech. + + 2/ I am pretty sure the Lincoln Lab sinusoidal coding guys (like xMBE + also from MIT) first described this zero phase model, I need to look + up the paper. + + 3/ Note that this approach could cause some discontinuities in + the phase at the edge of synthesis frames, as no attempt is made + to make sure that the phase tracks are continuous (the excitation + phases are continuous, but not the final phases after filtering + by the LPC spectra). Technically this is a bad thing. However + this may actually be a good thing, disturbing the phase tracks a + bit. More research needed, e.g. test a synthesis model that adds + a small delta-W to make phase tracks line up for voiced + harmonics. + +\*---------------------------------------------------------------------------*/ + +void CCodec2::phase_synth_zero_order( + int n_samp, + MODEL *model, + float *ex_phase, /* excitation phase of fundamental */ + std::complex H[] /* L synthesis filter freq domain samples */ + +) +{ + int m; + float new_phi; + std::complex Ex[MAX_AMP+1]; /* excitation samples */ + std::complex A_[MAX_AMP+1]; /* synthesised harmonic samples */ + + /* + Update excitation fundamental phase track, this sets the position + of each pitch pulse during voiced speech. After much experiment + I found that using just this frame's Wo improved quality for UV + sounds compared to interpolating two frames Wo like this: + + ex_phase[0] += (*prev_Wo+model->Wo)*N_SAMP/2; + */ + + ex_phase[0] += (model->Wo)*n_samp; + ex_phase[0] -= TWO_PI*floorf(ex_phase[0]/TWO_PI + 0.5); + + for(m=1; m<=model->L; m++) + { + + /* generate excitation */ + + if (model->voiced) + { + Ex[m] = std::polar(1.0f, ex_phase[0] * m); + } + else + { + + /* When a few samples were tested I found that LPC filter + phase is not needed in the unvoiced case, but no harm in + keeping it. + */ + float phi = TWO_PI*(float)codec2_rand()/CODEC2_RAND_MAX; + Ex[m] = std::polar(1.0f, phi); + } + + /* filter using LPC filter */ + + A_[m].real(H[m].real() * Ex[m].real() - H[m].imag() * Ex[m].imag()); + A_[m].imag(H[m].imag() * Ex[m].real() + H[m].real() * Ex[m].imag()); + + /* modify sinusoidal phase */ + + new_phi = atan2f(A_[m].imag(), A_[m].real()+1E-12); + model->phi[m] = new_phi; + } + +} + +/*---------------------------------------------------------------------------*\ + + postfilter() + + The post filter is designed to help with speech corrupted by + background noise. The zero phase model tends to make speech with + background noise sound "clicky". With high levels of background + noise the low level inter-formant parts of the spectrum will contain + noise rather than speech harmonics, so modelling them as voiced + (i.e. a continuous, non-random phase track) is inaccurate. + + Some codecs (like MBE) have a mixed voicing model that breaks the + spectrum into voiced and unvoiced regions. Several bits/frame + (5-12) are required to transmit the frequency selective voicing + information. Mixed excitation also requires accurate voicing + estimation (parameter estimators always break occasionally under + exceptional conditions). + + In our case we use a post filter approach which requires no + additional bits to be transmitted. The decoder measures the average + level of the background noise during unvoiced frames. If a harmonic + is less than this level it is made unvoiced by randomising it's + phases. + + This idea is rather experimental. Some potential problems that may + happen: + + 1/ If someone says "aaaaaaaahhhhhhhhh" will background estimator track + up to speech level? This would be a bad thing. + + 2/ If background noise suddenly dissapears from the source speech does + estimate drop quickly? What is noise suddenly re-appears? + + 3/ Background noise with a non-flat sepctrum. Current algorithm just + comsiders spectrum as a whole, but this could be broken up into + bands, each with their own estimator. + + 4/ Males and females with the same level of background noise. Check + performance the same. Changing Wo affects width of each band, may + affect bg energy estimates. + + 5/ Not sure what happens during long periods of voiced speech + e.g. "sshhhhhhh" + +\*---------------------------------------------------------------------------*/ + +#define BG_THRESH 40.0 // only consider low levels signals for bg_est +#define BG_BETA 0.1 // averaging filter constant +#define BG_MARGIN 6.0 // harmonics this far above BG noise are + // randomised. Helped make bg noise less + // spikey (impulsive) for mmt1, but speech was + // perhaps a little rougher. + +void CCodec2::postfilter( MODEL *model, float *bg_est ) +{ + int m, uv; + float e, thresh; + + /* determine average energy across spectrum */ + + e = 1E-12; + for(m=1; m<=model->L; m++) + e += model->A[m]*model->A[m]; + + assert(e > 0.0); + e = 10.0*log10f(e/model->L); + + /* If beneath threhold, update bg estimate. The idea + of the threshold is to prevent updating during high level + speech. */ + + if ((e < BG_THRESH) && !model->voiced) + *bg_est = *bg_est*(1.0 - BG_BETA) + e*BG_BETA; + + /* now mess with phases during voiced frames to make any harmonics + less then our background estimate unvoiced. + */ + + uv = 0; + thresh = exp10f((*bg_est + BG_MARGIN)/20.0); + if (model->voiced) + for(m=1; m<=model->L; m++) + if (model->A[m] < thresh) + { + model->phi[m] = (TWO_PI/CODEC2_RAND_MAX)*(float)codec2_rand(); + uv++; + } +} + +C2CONST CCodec2::c2const_create(int Fs, float framelength_s) +{ + C2CONST c2const; + + assert((Fs == 8000) || (Fs = 16000)); + c2const.Fs = Fs; + c2const.n_samp = round(Fs*framelength_s); + c2const.max_amp = floor(Fs*P_MAX_S/2); + c2const.p_min = floor(Fs*P_MIN_S); + c2const.p_max = floor(Fs*P_MAX_S); + c2const.m_pitch = floor(Fs*M_PITCH_S); + c2const.Wo_min = TWO_PI/c2const.p_max; + c2const.Wo_max = TWO_PI/c2const.p_min; + + if (Fs == 8000) + { + c2const.nw = 279; + } + else + { + c2const.nw = 511; /* actually a bit shorter in time but lets us maintain constant FFT size */ + } + + c2const.tw = Fs*TW_S; + + /* + fprintf(stderr, "max_amp: %d m_pitch: %d\n", c2const.n_samp, c2const.m_pitch); + fprintf(stderr, "p_min: %d p_max: %d\n", c2const.p_min, c2const.p_max); + fprintf(stderr, "Wo_min: %f Wo_max: %f\n", c2const.Wo_min, c2const.Wo_max); + fprintf(stderr, "nw: %d tw: %d\n", c2const.nw, c2const.tw); + */ + + return c2const; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: make_analysis_window + AUTHOR......: David Rowe + DATE CREATED: 11/5/94 + + Init function that generates the time domain analysis window and it's DFT. + +\*---------------------------------------------------------------------------*/ + +void CCodec2::make_analysis_window(C2CONST *c2const, FFT_STATE *fft_fwd_cfg, float w[], float W[]) +{ + float m; + std::complex wshift[FFT_ENC]; + int i,j; + int m_pitch = c2const->m_pitch; + int nw = c2const->nw; + + /* + Generate Hamming window centered on M-sample pitch analysis window + + 0 M/2 M-1 + |-------------|-------------| + |-------|-------| + nw samples + + All our analysis/synthsis is centred on the M/2 sample. + */ + + m = 0.0; + for(i=0; i temp[FFT_ENC]; + + for(i=0; i(0.0f, 0.0f); + } + for(i=0; i Sw[], float Sn[], float w[]) +{ + int i; + int m_pitch = c2const->m_pitch; + int nw = c2const->nw; + + for(i=0; i(0.0f, 0.0f); + } + + /* Centre analysis window on time axis, we need to arrange input + to FFT this way to make FFT phases correct */ + + /* move 2nd half to start of FFT input vector */ + + for(i=0; i Sw[]) +{ + float pmin,pmax,pstep; /* pitch refinment minimum, maximum and step */ + + /* Coarse refinement */ + + pmax = TWO_PI/model->Wo + 5; + pmin = TWO_PI/model->Wo - 5; + pstep = 1.0; + hs_pitch_refinement(model, Sw, pmin, pmax, pstep); + + /* Fine refinement */ + + pmax = TWO_PI/model->Wo + 1; + pmin = TWO_PI/model->Wo - 1; + pstep = 0.25; + hs_pitch_refinement(model,Sw,pmin,pmax,pstep); + + /* Limit range */ + + if (model->Wo < TWO_PI/c2const->p_max) + model->Wo = TWO_PI/c2const->p_max; + if (model->Wo > TWO_PI/c2const->p_min) + model->Wo = TWO_PI/c2const->p_min; + + model->L = floorf(PI/model->Wo); + + /* trap occasional round off issues with floorf() */ + if (model->Wo*model->L >= 0.95*PI) + { + model->L--; + } + assert(model->Wo*model->L < PI); +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: hs_pitch_refinement + AUTHOR......: David Rowe + DATE CREATED: 27/5/94 + + Harmonic sum pitch refinement function. + + pmin pitch search range minimum + pmax pitch search range maximum + step pitch search step size + model current pitch estimate in model.Wo + + model refined pitch estimate in model.Wo + +\*---------------------------------------------------------------------------*/ + +void CCodec2::hs_pitch_refinement(MODEL *model, std::complex Sw[], float pmin, float pmax, float pstep) +{ + int m; /* loop variable */ + int b; /* bin for current harmonic centre */ + float E; /* energy for current pitch*/ + float Wo; /* current "test" fundamental freq. */ + float Wom; /* Wo that maximises E */ + float Em; /* mamimum energy */ + float r, one_on_r; /* number of rads/bin */ + float p; /* current pitch */ + + /* Initialisation */ + + model->L = PI/model->Wo; /* use initial pitch est. for L */ + Wom = model->Wo; + Em = 0.0; + r = TWO_PI/FFT_ENC; + one_on_r = 1.0/r; + + /* Determine harmonic sum for a range of Wo values */ + + for(p=pmin; p<=pmax; p+=pstep) + { + E = 0.0; + Wo = TWO_PI/p; + + /* Sum harmonic magnitudes */ + for(m=1; m<=model->L; m++) + { + b = (int)(m*Wo*one_on_r + 0.5); + E += Sw[b].real() * Sw[b].real() + Sw[b].imag() * Sw[b].imag(); + } + /* Compare to see if this is a maximum */ + + if (E > Em) + { + Em = E; + Wom = Wo; + } + } + + model->Wo = Wom; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: estimate_amplitudes + AUTHOR......: David Rowe + DATE CREATED: 27/5/94 + + Estimates the complex amplitudes of the harmonics. + +\*---------------------------------------------------------------------------*/ + +void CCodec2::estimate_amplitudes(MODEL *model, std::complex Sw[], int est_phase) +{ + int i,m; /* loop variables */ + int am,bm; /* bounds of current harmonic */ + float den; /* denominator of amplitude expression */ + + float r = TWO_PI/FFT_ENC; + float one_on_r = 1.0/r; + + for(m=1; m<=model->L; m++) + { + /* Estimate ampltude of harmonic */ + + den = 0.0; + am = (int)((m - 0.5)*model->Wo*one_on_r + 0.5); + bm = (int)((m + 0.5)*model->Wo*one_on_r + 0.5); + + for(i=am; iA[m] = sqrtf(den); + + if (est_phase) + { + int b = (int)(m*model->Wo/r + 0.5); /* DFT bin of centre of current harmonic */ + + /* Estimate phase of harmonic, this is expensive in CPU for + embedded devicesso we make it an option */ + + model->phi[m] = atan2f(Sw[b].imag(), Sw[b].real()); + } + } +} + +/*---------------------------------------------------------------------------*\ + + est_voicing_mbe() + + Returns the error of the MBE cost function for a fiven F0. + + Note: I think a lot of the operations below can be simplified as + W[].imag = 0 and has been normalised such that den always equals 1. + +\*---------------------------------------------------------------------------*/ + +float CCodec2::est_voicing_mbe( C2CONST *c2const, MODEL *model, std::complex Sw[], float W[]) +{ + int l,al,bl,m; /* loop variables */ + std::complex Am; /* amplitude sample for this band */ + int offset; /* centers Hw[] about current harmonic */ + float den; /* denominator of Am expression */ + float error; /* accumulated error between original and synthesised */ + float Wo; + float sig, snr; + float elow, ehigh, eratio; + float sixty; + std::complex Ew(0, 0); + + int l_1000hz = model->L*1000.0/(c2const->Fs/2); + sig = 1E-4; + for(l=1; l<=l_1000hz; l++) + { + sig += model->A[l]*model->A[l]; + } + + Wo = model->Wo; + error = 1E-4; + + /* Just test across the harmonics in the first 1000 Hz */ + + for(l=1; l<=l_1000hz; l++) + { + Am = std::complex(0.0f, 0.0f); + den = 0.0; + al = ceilf((l - 0.5)*Wo*FFT_ENC/TWO_PI); + bl = ceilf((l + 0.5)*Wo*FFT_ENC/TWO_PI); + + /* Estimate amplitude of harmonic assuming harmonic is totally voiced */ + + offset = FFT_ENC/2 - l*Wo*FFT_ENC/TWO_PI + 0.5; + for(m=al; m V_THRESH) + model->voiced = 1; + else + model->voiced = 0; + + /* post processing, helps clean up some voicing errors ------------------*/ + + /* + Determine the ratio of low freqency to high frequency energy, + voiced speech tends to be dominated by low frequency energy, + unvoiced by high frequency. This measure can be used to + determine if we have made any gross errors. + */ + + int l_2000hz = model->L*2000.0/(c2const->Fs/2); + int l_4000hz = model->L*4000.0/(c2const->Fs/2); + elow = ehigh = 1E-4; + for(l=1; l<=l_2000hz; l++) + { + elow += model->A[l]*model->A[l]; + } + for(l=l_2000hz; l<=l_4000hz; l++) + { + ehigh += model->A[l]*model->A[l]; + } + eratio = 10.0*log10f(elow/ehigh); + + /* Look for Type 1 errors, strongly V speech that has been + accidentally declared UV */ + + if (model->voiced == 0) + if (eratio > 10.0) + model->voiced = 1; + + /* Look for Type 2 errors, strongly UV speech that has been + accidentally declared V */ + + if (model->voiced == 1) + { + if (eratio < -10.0) + model->voiced = 0; + + /* A common source of Type 2 errors is the pitch estimator + gives a low (50Hz) estimate for UV speech, which gives a + good match with noise due to the close harmoonic spacing. + These errors are much more common than people with 50Hz3 + pitch, so we have just a small eratio threshold. */ + + sixty = 60.0*TWO_PI/c2const->Fs; + if ((eratio < -4.0) && (model->Wo <= sixty)) + model->voiced = 0; + } + //printf(" v: %d snr: %f eratio: %3.2f %f\n",model->voiced,snr,eratio,dF0); + + return snr; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: make_synthesis_window + AUTHOR......: David Rowe + DATE CREATED: 11/5/94 + + Init function that generates the trapezoidal (Parzen) sythesis window. + +\*---------------------------------------------------------------------------*/ + +void CCodec2::make_synthesis_window(C2CONST *c2const, float Pn[]) +{ + int i; + float win; + int n_samp = c2const->n_samp; + int tw = c2const->tw; + + /* Generate Parzen window in time domain */ + + win = 0.0; + for(i=0; i Sw_[FFT_DEC/2+1]; /* DFT of synthesised signal */ + float sw_[FFT_DEC]; /* synthesised signal */ + + if (shift) + { + /* Update memories */ + for(i=0; iL; l++) + { + b = (int)(l*model->Wo*FFT_DEC/TWO_PI + 0.5); + if (b > ((FFT_DEC/2)-1)) + { + b = (FFT_DEC/2)-1; + } + Sw_[b] = std::polar(model->A[l], model->phi[l]); + } + + /* Perform inverse DFT */ + + kiss.fftri(*fftr_inv_cfg, Sw_,sw_); + + /* Overlap add to previous samples */ + + for(i=0; ivoiced && !prev->voiced && !next->voiced) + { + interp->voiced = 0; + } + + /* Wo depends on voicing of this and adjacent frames */ + + if (interp->voiced) + { + if (prev->voiced && next->voiced) + interp->Wo = (1.0 - weight)*prev->Wo + weight*next->Wo; + if (!prev->voiced && next->voiced) + interp->Wo = next->Wo; + if (prev->voiced && !next->voiced) + interp->Wo = prev->Wo; + } + else + { + interp->Wo = Wo_min; + } + interp->L = PI/interp->Wo; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: interp_energy() + AUTHOR......: David Rowe + DATE CREATED: 22 May 2012 + + Interpolates centre 10ms sample of energy given two samples 20ms + apart. + +\*---------------------------------------------------------------------------*/ + +float CCodec2::interp_energy(float prev_e, float next_e) +{ + //return powf(10.0, (log10f(prev_e) + log10f(next_e))/2.0); + return sqrtf(prev_e * next_e); //looks better is math. identical and faster math +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: interpolate_lsp_ver2() + AUTHOR......: David Rowe + DATE CREATED: 22 May 2012 + + Weighted interpolation of LSPs. + +\*---------------------------------------------------------------------------*/ + +void CCodec2::interpolate_lsp_ver2(float interp[], float prev[], float next[], float weight, int order) +{ + int i; + + for(i=0; i. +*/ + +#ifndef __CODEC2__ +#define __CODEC2__ + +#include + +#include "codec2_internal.h" +#include "defines.h" +#include "kiss_fft.h" +#include "nlp.h" +#include "quantise.h" + +#define CODEC2_MODE_3200 0 +#define CODEC2_MODE_1600 2 + +#ifndef CODEC2_MODE_EN_DEFAULT +#define CODEC2_MODE_EN_DEFAULT 1 +#endif + +#define CODEC2_RAND_MAX 32767 + +class CCodec2 +{ +public: + CCodec2(bool is_3200); + ~CCodec2(); + void codec2_encode(unsigned char *bits, const short *speech_in); + void codec2_decode(short *speech_out, const unsigned char *bits); + void codec2_set_mode(bool); + bool codec2_get_mode() {return (c2.mode == 3200); }; + int codec2_samples_per_frame(); + int codec2_bits_per_frame(); + +private: + // merged from other files + void sample_phase(MODEL *model, std::complex filter_phase[], std::complex A[]); + void phase_synth_zero_order(int n_samp, MODEL *model, float *ex_phase, std::complex filter_phase[]); + void postfilter(MODEL *model, float *bg_est); + + C2CONST c2const_create(int Fs, float framelength_ms); + + void make_analysis_window(C2CONST *c2const, FFT_STATE *fft_fwd_cfg, float w[], float W[]); + void dft_speech(C2CONST *c2const, FFT_STATE &fft_fwd_cfg, std::complex Sw[], float Sn[], float w[]); + void two_stage_pitch_refinement(C2CONST *c2const, MODEL *model, std::complex Sw[]); + void estimate_amplitudes(MODEL *model, std::complex Sw[], int est_phase); + float est_voicing_mbe(C2CONST *c2const, MODEL *model, std::complex Sw[], float W[]); + void make_synthesis_window(C2CONST *c2const, float Pn[]); + void synthesise(int n_samp, FFTR_STATE *fftr_inv_cfg, float Sn_[], MODEL *model, float Pn[], int shift); + int codec2_rand(void); + void hs_pitch_refinement(MODEL *model, std::complex Sw[], float pmin, float pmax, float pstep); + + void interp_Wo(MODEL *interp, MODEL *prev, MODEL *next, float Wo_min); + void interp_Wo2(MODEL *interp, MODEL *prev, MODEL *next, float weight, float Wo_min); + float interp_energy(float prev, float next); + void interpolate_lsp_ver2(float interp[], float prev[], float next[], float weight, int order); + + void analyse_one_frame(MODEL *model, const short *speech); + void synthesise_one_frame(short speech[], MODEL *model, std::complex Aw[], float gain); + void codec2_encode_3200(unsigned char *bits, const short *speech); + void codec2_encode_1600(unsigned char *bits, const short *speech); + void codec2_decode_3200(short *speech, const unsigned char *bits); + void codec2_decode_1600(short *speech, const unsigned char *bits); + void ear_protection(float in_out[], int n); + void lsp_to_lpc(float *freq, float *ak, int lpcrdr); + + void (CCodec2::*encode)(unsigned char *bits, const short *speech); + void (CCodec2::*decode)(short *speech, const unsigned char *bits); + Cnlp nlp; + CQuantize qt; + CODEC2 c2; +}; + +#endif diff --git a/DMR2M17/codec2/codec2_internal.h b/DMR2M17/codec2/codec2_internal.h new file mode 100644 index 0000000..1b037e1 --- /dev/null +++ b/DMR2M17/codec2/codec2_internal.h @@ -0,0 +1,67 @@ +/*---------------------------------------------------------------------------*\ + + FILE........: codec2_internal.h + AUTHOR......: David Rowe + DATE CREATED: April 16 2012 + + Header file for Codec2 internal states, exposed via this header + file to assist in testing. + +\*---------------------------------------------------------------------------*/ + +/* + Copyright (C) 2012 David Rowe + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the Free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#ifndef __CODEC2_INTERNAL__ +#define __CODEC2_INTERNAL__ + +#include "kiss_fft.h" + +using CODEC2 = struct codec2_tag { + int mode; + int Fs; + int n_samp; + int m_pitch; + int gray; /* non-zero for gray encoding */ + int lpc_pf; /* LPC post filter on */ + int bass_boost; /* LPC post filter bass boost */ + int smoothing; /* enable smoothing for channels with errors */ + float ex_phase; /* excitation model phase track */ + float bg_est; /* background noise estimate for post filter */ + float prev_f0_enc; /* previous frame's f0 estimate */ + float prev_e_dec; /* previous frame's LPC energy */ + float beta; /* LPC post filter parameters */ + float gamma; + float xq_enc[2]; /* joint pitch and energy VQ states */ + float xq_dec[2]; + float W[FFT_ENC]; /* DFT of w[] */ + float hpf_states[2]; /* high pass filter states */ + float prev_lsps_dec[LPC_ORD]; /* previous frame's LSPs */ + float *softdec; /* optional soft decn bits from demod */ + MODEL prev_model_dec; /* previous frame's model parameters */ + C2CONST c2const; + FFT_STATE fft_fwd_cfg; /* forward FFT config */ + FFTR_STATE fftr_fwd_cfg; /* forward real FFT config */ + FFTR_STATE fftr_inv_cfg; /* inverse FFT config */ + std::vector w; /* [m_pitch] time domain hamming window */ + std::vector Pn; /* [2*n_samp] trapezoidal synthesis window */ + std::vector Sn; /* [m_pitch] input speech */ + std::vector Sn_; /* [2*n_samp] synthesised output speech */ + std::vector bpf_buf; /* buffer for band pass filter */ +}; + +#endif diff --git a/DMR2M17/codec2/defines.h b/DMR2M17/codec2/defines.h new file mode 100644 index 0000000..f201313 --- /dev/null +++ b/DMR2M17/codec2/defines.h @@ -0,0 +1,127 @@ +/*---------------------------------------------------------------------------*\ + + FILE........: defines.h + AUTHOR......: David Rowe + DATE CREATED: 23/4/93 + + Defines and structures used throughout the codec. + +\*---------------------------------------------------------------------------*/ + +/* + Copyright (C) 2009 David Rowe + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the Free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#ifndef __DEFINES__ +#define __DEFINES__ + +#include +#include + +/*---------------------------------------------------------------------------*\ + + DEFINES + +\*---------------------------------------------------------------------------*/ + +/* General defines */ + +#define N_S 0.01 /* internal proc frame length in secs */ +#define TW_S 0.005 /* trapezoidal synth window overlap */ +#define MAX_AMP 160 /* maximum number of harmonics */ +#ifndef PI +#define PI 3.141592654 /* mathematical constant */ +#endif +#define TWO_PI 6.283185307 /* mathematical constant */ +#define MAX_STR 2048 /* maximum string size */ + +#define FFT_ENC 512 /* size of FFT used for encoder */ +#define FFT_DEC 512 /* size of FFT used in decoder */ +#define V_THRESH 6.0 /* voicing threshold in dB */ +#define LPC_ORD 10 /* LPC order */ +#define LPC_ORD_LOW 6 /* LPC order for lower rates */ + +/* Pitch estimation defines */ + +#define M_PITCH_S 0.0400 /* pitch analysis window in s */ +#define P_MIN_S 0.0025 /* minimum pitch period in s */ +#define P_MAX_S 0.0200 /* maximum pitch period in s */ +#define MAXFACTORS 32 // e.g. an fft of length 128 has 4 factors + // as far as kissfft is concerned 4*4*4*2 + +/*---------------------------------------------------------------------------*\ + + TYPEDEFS + +\*---------------------------------------------------------------------------*/ + +/* Structure to hold constants calculated at run time based on sample rate */ + +using C2CONST = struct c2const_tag +{ + int Fs; /* sample rate of this instance */ + int n_samp; /* number of samples per 10ms frame at Fs */ + int max_amp; /* maximum number of harmonics */ + int m_pitch; /* pitch estimation window size in samples */ + int p_min; /* minimum pitch period in samples */ + int p_max; /* maximum pitch period in samples */ + float Wo_min; + float Wo_max; + int nw; /* analysis window size in samples */ + int tw; /* trapezoidal synthesis window overlap */ +}; + +/* Structure to hold model parameters for one frame */ + +using MODEL = struct model_tag +{ + float Wo; /* fundamental frequency estimate in radians */ + int L; /* number of harmonics */ + float A[MAX_AMP+1]; /* amplitiude of each harmonic */ + float phi[MAX_AMP+1]; /* phase of each harmonic */ + int voiced; /* non-zero if this frame is voiced */ +}; + +/* describes each codebook */ + +struct lsp_codebook +{ + int k; /* dimension of vector */ + int log2m; /* number of bits in m */ + int m; /* elements in codebook */ + float *cb; /* The elements */ +}; + +using FFT_STATE = struct fft_state_tag +{ + int nfft; + bool inverse; + int factors[2*MAXFACTORS]; + std::vector> twiddles; +}; + +using FFTR_STATE = struct fftr_state_tag +{ + FFT_STATE substate; + std::vector> tmpbuf; + std::vector> super_twiddles; +}; + +extern const struct lsp_codebook lsp_cb[]; +extern const struct lsp_codebook lsp_cbd[]; +extern const struct lsp_codebook ge_cb[]; + +#endif diff --git a/DMR2M17/codec2/kiss_fft.cpp b/DMR2M17/codec2/kiss_fft.cpp new file mode 100644 index 0000000..cefb846 --- /dev/null +++ b/DMR2M17/codec2/kiss_fft.cpp @@ -0,0 +1,435 @@ +/* +Copyright (c) 2003-2010, Mark Borgerding + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + * Neither the author nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include +#include + +#include "defines.h" +#include "kiss_fft.h" + +void CKissFFT::kf_bfly2(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m) +{ + std::complex *Fout2; + std::complex *tw1 = st.twiddles.data(); + std::complex t; + Fout2 = Fout + m; + do + { + t = *Fout2 * *tw1; + tw1 += fstride; + *Fout2 = *Fout - t; + *Fout += t; + ++Fout2; + ++Fout; + } + while (--m); +} + +void CKissFFT::kf_bfly3(std::complex * Fout, const size_t fstride, FFT_STATE &st, int m) +{ + const size_t m2 = 2 * m; + std::complex *tw1,*tw2; + std::complex scratch[5]; + std::complex epi3; + epi3 = st.twiddles[fstride*m]; + + tw1 = tw2 = st.twiddles.data(); + + do + { + scratch[1] = Fout[m] * *tw1; + scratch[2] = Fout[m2] * *tw2; + + scratch[3] = scratch[1] + scratch[2]; + scratch[0] = scratch[1] - scratch[2]; + tw1 += fstride; + tw2 += fstride*2; + + Fout[m] = *Fout - (0.5f * scratch[3]); + + scratch[0] *= epi3.imag(); + + *Fout += scratch[3]; + + Fout[m2].real(Fout[m].real() + scratch[0].imag()); + Fout[m2].imag(Fout[m].imag() - scratch[0].real()); + + Fout[m].real(Fout[m].real() - scratch[0].imag()); + Fout[m].imag(Fout[m].imag() + scratch[0].real()); + + ++Fout; + } + while(--m); +} + +void CKissFFT::kf_bfly4(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m) +{ + std::complex *tw1,*tw2,*tw3; + std::complex scratch[6]; + int k = m; + const int m2 = 2 * m; + const int m3 = 3 * m; + + + tw3 = tw2 = tw1 = st.twiddles.data(); + + do + { + scratch[0] = Fout[m] * *tw1; + scratch[1] = Fout[m2] * *tw2; + scratch[2] = Fout[m3] * *tw3; + + scratch[5] = *Fout - scratch[1]; + *Fout += scratch[1]; + scratch[3] = scratch[0] + scratch[2]; + scratch[4] = scratch[0] - scratch[2]; + Fout[m2] = *Fout - scratch[3]; + tw1 += fstride; + tw2 += fstride*2; + tw3 += fstride*3; + *Fout += scratch[3]; + + if(st.inverse) + { + Fout[m].real(scratch[5].real() - scratch[4].imag()); + Fout[m].imag(scratch[5].imag() + scratch[4].real()); + Fout[m3].real(scratch[5].real() + scratch[4].imag()); + Fout[m3].imag(scratch[5].imag() - scratch[4].real()); + } + else + { + Fout[m].real(scratch[5].real() + scratch[4].imag()); + Fout[m].imag(scratch[5].imag() - scratch[4].real()); + Fout[m3].real(scratch[5].real() - scratch[4].imag()); + Fout[m3].imag(scratch[5].imag() + scratch[4].real()); + } + ++Fout; + } + while(--k); +} + +void CKissFFT::kf_bfly5(std::complex * Fout, const size_t fstride, FFT_STATE &st, int m) +{ + std::complex scratch[13]; + std::complex *twiddles = st.twiddles.data(); + auto ya = twiddles[fstride*m]; + auto yb = twiddles[fstride*2*m]; + + auto Fout0 = Fout; + auto Fout1 = Fout0 + m; + auto Fout2 = Fout0 + 2 * m; + auto Fout3 = Fout0 + 3 * m; + auto Fout4 = Fout0 + 4 * m; + + auto tw = st.twiddles.data(); + for (int u=0; u *Fout, const size_t fstride, FFT_STATE &st, int m, int p) +{ + auto twiddles = st.twiddles.data(); + std::complex t; + int Norig = st.nfft; + + std::vector> scratch(p); + + for (int u=0; u= Norig) twidx-=Norig; + t = scratch[q] * twiddles[twidx]; + Fout[k] += t; + } + k += m; + } + } + scratch.clear(); +} + +void CKissFFT::kf_work(std::complex *Fout, const std::complex *f, const size_t fstride, int in_stride, int *factors, FFT_STATE &st) +{ + auto Fout_beg = Fout; + const int p = *factors++; /* the radix */ + const int m = *factors++; /* stage's fft length/p */ + const std::complex *Fout_end = Fout + p*m; + + if (m==1) + { + do + { + *Fout = *f; + f += fstride*in_stride; + } + while( ++Fout != Fout_end ); + } + else + { + do + { + // recursive call: + // DFT of size m*p performed by doing + // p instances of smaller DFTs of size m, + // each one takes a decimated version of the input + kf_work( Fout, f, fstride*p, in_stride, factors, st); + f += fstride*in_stride; + } + while( (Fout += m) != Fout_end ); + } + + Fout=Fout_beg; + + // recombine the p smaller DFTs + switch (p) + { + case 2: + kf_bfly2(Fout,fstride,st,m); + break; + case 3: + kf_bfly3(Fout,fstride,st,m); + break; + case 4: + kf_bfly4(Fout,fstride,st,m); + break; + case 5: + kf_bfly5(Fout,fstride,st,m); + break; + default: + kf_bfly_generic(Fout,fstride,st,m,p); + break; + } +} + +/* facbuf is populated by p1,m1,p2,m2, ... + where + p[i] * m[i] = m[i-1] + m0 = n */ +void CKissFFT::kf_factor(int n,int * facbuf) +{ + int p=4; + double floor_sqrt; + floor_sqrt = floorf( sqrtf((double)n) ); + + /*factor out powers of 4, powers of 2, then any remaining primes */ + do + { + while (n % p) + { + switch (p) + { + case 4: + p = 2; + break; + case 2: + p = 3; + break; + default: + p += 2; + break; + } + if (p > floor_sqrt) + p = n; /* no more factors, skip to end */ + } + n /= p; + *facbuf++ = p; + *facbuf++ = n; + } + while (n > 1); +} + +void CKissFFT::fft_alloc(FFT_STATE &state, const int nfft, bool inverse_fft) +{ + state.twiddles.resize(nfft); + + state.nfft = nfft; + state.inverse = inverse_fft; + + for (int i=0; i *fin, std::complex *fout, int in_stride) +{ + if (fin == fout) + { + //NOTE: this is not really an in-place FFT algorithm. + //It just performs an out-of-place FFT into a temp buffer + std::vector> tmpbuf(st.nfft); + kf_work(tmpbuf.data(), fin, true, in_stride, st.factors, st); + memcpy(fout, tmpbuf.data(), sizeof(std::complex)*st.nfft); + tmpbuf.clear(); + } + else + { + kf_work(fout, fin, 1, in_stride, st.factors, st); + } +} + +void CKissFFT::fft(FFT_STATE &cfg, const std::complex *fin, std::complex *fout) +{ + fft_stride(cfg, fin, fout, 1); +} + +int CKissFFT::fft_next_fast_size(int n) +{ + while(1) + { + int m = n; + while ( (m % 2) == 0 ) m /= 2; + while ( (m % 3) == 0 ) m /= 3; + while ( (m % 5) == 0 ) m /= 5; + if (m <= 1) + break; /* n is completely factorable by twos, threes, and fives */ + n++; + } + return n; +} + +void CKissFFT::fftr_alloc(FFTR_STATE &st, int nfft, const bool inverse_fft) +{ + nfft >>= 1; + + fft_alloc(st.substate, nfft, inverse_fft); + st.tmpbuf.resize(nfft); + st.super_twiddles.resize(nfft); + + for (int i=0; i *freqdata) +{ + assert(st.substate.inverse == false); + + auto ncfft = st.substate.nfft; + + /*perform the parallel fft of two real signals packed in real,imag*/ + fft( st.substate, (const std::complex*)timedata, st.tmpbuf.data()); + /* The real part of the DC element of the frequency spectrum in st->tmpbuf + * contains the sum of the even-numbered elements of the input time sequence + * The imag part is the sum of the odd-numbered elements + * + * The sum of tdc.r and tdc.i is the sum of the input time sequence. + * yielding DC of input time sequence + * The difference of tdc.r - tdc.i is the sum of the input (dot product) [1,-1,1,-1... + * yielding Nyquist bin of input time sequence + */ + + auto tdc = st.tmpbuf[0]; + freqdata[0].real(tdc.real() + tdc.imag()); + freqdata[ncfft].real(tdc.real() - tdc.imag()); + freqdata[ncfft].imag(0.f); + freqdata[0].imag(0.f); + + for (int k=1; k <= ncfft/2; ++k) + { + auto fpk = st.tmpbuf[k]; + auto fpnk = std::conj(st.tmpbuf[ncfft-k]); + + auto f1k = fpk + fpnk; + auto f2k = fpk - fpnk; + auto tw = f2k * st.super_twiddles[k-1]; + + freqdata[k] = 0.5f * (f1k + tw); + freqdata[ncfft-k].real(0.5f * (f1k.real() - tw.real())); + freqdata[ncfft-k].imag(0.5f * (tw.imag() - f1k.imag())); + } +} + +void CKissFFT::fftri(FFTR_STATE &st, const std::complex *freqdata, float *timedata) +{ + assert(st.substate.inverse == true); + + auto ncfft = st.substate.nfft; + + st.tmpbuf[0].real(freqdata[0].real() + freqdata[ncfft].real()); + st.tmpbuf[0].imag(freqdata[0].real() - freqdata[ncfft].real()); + + for (int k=1; k <= ncfft/2; ++k) + { + auto fk = freqdata[k]; + auto fnkc = std::conj(freqdata[ncfft - k]); + + auto fek = fk + fnkc; + auto tmp = fk - fnkc; + auto fok = tmp * st.super_twiddles[k-1]; + st.tmpbuf[k] = fek + fok; + st.tmpbuf[ncfft - k] = std::conj(fek - fok); + } + fft (st.substate, st.tmpbuf.data(), (std::complex *)timedata); +} diff --git a/DMR2M17/codec2/kiss_fft.h b/DMR2M17/codec2/kiss_fft.h new file mode 100644 index 0000000..7626617 --- /dev/null +++ b/DMR2M17/codec2/kiss_fft.h @@ -0,0 +1,35 @@ +#ifndef KISS_FFT_H +#define KISS_FFT_H + +#include + +#include +#include +#include +#include + +#include "defines.h" + +/* for real ffts, we need an even size */ +#define kiss_fftr_next_fast_size_real(n) (kiss_fft_next_fast_size( ((n)+1) >> 1) << 1 ) + +class CKissFFT +{ +public: + void fft_alloc(FFT_STATE &state, const int nfft, const bool inverse_fft); + void fft(FFT_STATE &cfg, const std::complex *fin, std::complex *fout); + void fft_stride(FFT_STATE &cfg, const std::complex *fin, std::complex *fout, int fin_stride); + int fft_next_fast_size(int n); + void fftr_alloc(FFTR_STATE &state, int nfft, const bool inverse_fft); + void fftr(FFTR_STATE &cfg,const float *timedata,std::complex *freqdata); + void fftri(FFTR_STATE &cfg,const std::complex *freqdata,float *timedata); +private: + void kf_bfly2(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m); + void kf_bfly3(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m); + void kf_bfly4(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m); + void kf_bfly5(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m); + void kf_bfly_generic(std::complex *Fout, const size_t fstride, FFT_STATE &st, int m, int p); + void kf_work(std::complex *Fout, const std::complex *f, const size_t fstride, int in_stride, int *factors, FFT_STATE &st); + void kf_factor(int n, int *facbuf); +}; +#endif diff --git a/DMR2M17/codec2/lpc.cpp b/DMR2M17/codec2/lpc.cpp new file mode 100644 index 0000000..10f2c09 --- /dev/null +++ b/DMR2M17/codec2/lpc.cpp @@ -0,0 +1,311 @@ +/*---------------------------------------------------------------------------*\ + + FILE........: lpc.c + AUTHOR......: David Rowe + DATE CREATED: 30 Sep 1990 (!) + + Linear Prediction functions written in C. + +\*---------------------------------------------------------------------------*/ + +/* + Copyright (C) 2009-2012 David Rowe + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the Free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#define LPC_MAX_N 512 /* maximum no. of samples in frame */ +#define PI 3.141592654 /* mathematical constant */ + +#define ALPHA 1.0 +#define BETA 0.94 + +#include +#include +#include "defines.h" +#include "lpc.h" + +/*---------------------------------------------------------------------------*\ + + pre_emp() + + Pre-emphasise (high pass filter with zero close to 0 Hz) a frame of + speech samples. Helps reduce dynamic range of LPC spectrum, giving + greater weight and hense a better match to low energy formants. + + Should be balanced by de-emphasis of the output speech. + +\*---------------------------------------------------------------------------*/ + +void Clpc::pre_emp( + float Sn_pre[], /* output frame of speech samples */ + float Sn[], /* input frame of speech samples */ + float *mem, /* Sn[-1]single sample memory */ + int Nsam /* number of speech samples to use */ +) +{ + int i; + + for(i=0; i 1.0) + k = 0.0; + + a[i][i] = k; + + for(j=1; j<=i-1; j++) + a[i][j] = a[i-1][j] + k*a[i-1][i-j]; /* Equation 38c, Makhoul */ + + e *= (1-k*k); /* Equation 38d, Makhoul */ + } + + for(i=1; i<=order; i++) + lpcs[i] = a[order][i]; + lpcs[0] = 1.0; +} + +/*---------------------------------------------------------------------------*\ + + inverse_filter() + + Inverse Filter, A(z). Produces an array of residual samples from an array + of input samples and linear prediction coefficients. + + The filter memory is stored in the first order samples of the input array. + +\*---------------------------------------------------------------------------*/ + +void Clpc::inverse_filter( + float Sn[], /* Nsam input samples */ + float a[], /* LPCs for this frame of samples */ + int Nsam, /* number of samples */ + float res[], /* Nsam residual samples */ + int order /* order of LPC */ +) +{ + int i,j; /* loop variables */ + + for(i=0; i. +*/ + +#ifndef __LPC__ +#define __LPC__ + +#define LPC_MAX_ORDER 20 + +class Clpc { +public: + void autocorrelate(float Sn[], float Rn[], int Nsam, int order); + void levinson_durbin(float R[], float lpcs[], int order); +private: + void pre_emp(float Sn_pre[], float Sn[], float *mem, int Nsam); + void de_emp(float Sn_se[], float Sn[], float *mem, int Nsam); + void hanning_window(float Sn[], float Wn[], int Nsam); + void inverse_filter(float Sn[], float a[], int Nsam, float res[], int order); + void synthesis_filter(float res[], float a[], int Nsam, int order, float Sn_[]); + void find_aks(float Sn[], float a[], int Nsam, int order, float *E); + void weight(float ak[], float gamma, int order, float akw[]); +}; + +#endif diff --git a/DMR2M17/codec2/nlp.cpp b/DMR2M17/codec2/nlp.cpp new file mode 100644 index 0000000..753e96b --- /dev/null +++ b/DMR2M17/codec2/nlp.cpp @@ -0,0 +1,520 @@ +/*---------------------------------------------------------------------------*\ + + FILE........: nlp.c + AUTHOR......: David Rowe + DATE CREATED: 23/3/93 + + Non Linear Pitch (NLP) estimation functions. + +\*---------------------------------------------------------------------------*/ + +/* + Copyright (C) 2009 David Rowe + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the Free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#include +#include +#include + +#include "defines.h" +#include "nlp.h" +#include "kiss_fft.h" + +extern CKissFFT kiss; + +/*---------------------------------------------------------------------------*\ + + GLOBALS + +\*---------------------------------------------------------------------------*/ + +/* 48 tap 600Hz low pass FIR filter coefficients */ + +static const float nlp_fir[] = +{ + -1.0818124e-03, + -1.1008344e-03, + -9.2768838e-04, + -4.2289438e-04, + 5.5034190e-04, + 2.0029849e-03, + 3.7058509e-03, + 5.1449415e-03, + 5.5924666e-03, + 4.3036754e-03, + 8.0284511e-04, + -4.8204610e-03, + -1.1705810e-02, + -1.8199275e-02, + -2.2065282e-02, + -2.0920610e-02, + -1.2808831e-02, + 3.2204775e-03, + 2.6683811e-02, + 5.5520624e-02, + 8.6305944e-02, + 1.1480192e-01, + 1.3674206e-01, + 1.4867556e-01, + 1.4867556e-01, + 1.3674206e-01, + 1.1480192e-01, + 8.6305944e-02, + 5.5520624e-02, + 2.6683811e-02, + 3.2204775e-03, + -1.2808831e-02, + -2.0920610e-02, + -2.2065282e-02, + -1.8199275e-02, + -1.1705810e-02, + -4.8204610e-03, + 8.0284511e-04, + 4.3036754e-03, + 5.5924666e-03, + 5.1449415e-03, + 3.7058509e-03, + 2.0029849e-03, + 5.5034190e-04, + -4.2289438e-04, + -9.2768838e-04, + -1.1008344e-03, + -1.0818124e-03 +}; + +static const float fdmdv_os_filter[]= { + -0.0008215855034550382, + -0.0007833023901802921, + 0.001075563790768233, + 0.001199092367787555, + -0.001765309502928316, + -0.002055372115328064, + 0.002986877604154257, + 0.003462567920638414, + -0.004856570111126334, + -0.005563143845031497, + 0.007533613299748122, + 0.008563932468880897, + -0.01126857129039911, + -0.01280782411693687, + 0.01651443896361847, + 0.01894875110322284, + -0.02421604439474981, + -0.02845107338464062, + 0.03672973563400258, + 0.04542046150312214, + -0.06189165826716491, + -0.08721876380763803, + 0.1496157094199961, + 0.4497962274137046, + 0.4497962274137046, + 0.1496157094199961, + -0.08721876380763803, + -0.0618916582671649, + 0.04542046150312216, + 0.03672973563400257, + -0.02845107338464062, + -0.02421604439474984, + 0.01894875110322284, + 0.01651443896361848, + -0.01280782411693687, + -0.0112685712903991, + 0.008563932468880899, + 0.007533613299748123, + -0.005563143845031501, + -0.004856570111126346, + 0.003462567920638419, + 0.002986877604154259, + -0.002055372115328063, + -0.001765309502928318, + 0.001199092367787557, + 0.001075563790768233, + -0.0007833023901802925, + -0.0008215855034550383 +}; + +/*---------------------------------------------------------------------------*\ + + nlp_create() + + Initialisation function for NLP pitch estimator. + +\*---------------------------------------------------------------------------*/ + +void Cnlp::nlp_create(C2CONST *c2const) +{ + int i; + int m = c2const->m_pitch; + int Fs = c2const->Fs; + + assert((Fs == 8000) || (Fs == 16000)); + snlp.Fs = Fs; + + snlp.m = m; + + /* if running at 16kHz allocate storage for decimating filter memory */ + + if (Fs == 16000) + { + snlp.Sn16k.resize(FDMDV_OS_TAPS_16K + c2const->n_samp); + for(i=0; i Sw[], /* Freq domain version of Sn[] */ +// float W[], /* Freq domain window */ + float *prev_f0 /* previous pitch f0 in Hz, memory for pitch tracking */ +) +{ + float notch; /* current notch filter output */ + std::complex Fw[PE_FFT_SIZE]; /* DFT of squared signal (input/output) */ + float gmax; + int gmax_bin; + int m, i, j; + float best_f0; + + m = snlp.m; + + /* Square, notch filter at DC, and LP filter vector */ + + /* If running at 16 kHz decimate to 8 kHz, as NLP ws designed for + Fs = 8kHz. The decimating filter introduces about 3ms of delay, + that shouldn't be a problem as pitch changes slowly. */ + + if (snlp.Fs == 8000) + { + /* Square latest input samples */ + + for(i=m-n; i gmax) + { + gmax = Fw[i].real(); + gmax_bin = i; + } + } + + best_f0 = post_process_sub_multiples(Fw, pmax, gmax, gmax_bin, prev_f0); + + /* Shift samples in buffer to make room for new samples */ + + for(i=0; i Fw[], int pmax, float gmax, int gmax_bin, float *prev_f0) +{ + int min_bin, cmax_bin; + int mult; + float thresh, best_f0; + int b, bmin, bmax, lmax_bin; + float lmax; + int prev_f0_bin; + + /* post process estimate by searching submultiples */ + + mult = 2; + min_bin = PE_FFT_SIZE*DEC/pmax; + cmax_bin = gmax_bin; + prev_f0_bin = *prev_f0*(PE_FFT_SIZE*DEC)/SAMPLE_RATE; + + while(gmax_bin/mult >= min_bin) + { + + b = gmax_bin/mult; /* determine search interval */ + bmin = 0.8*b; + bmax = 1.2*b; + if (bmin < min_bin) + bmin = min_bin; + + /* lower threshold to favour previous frames pitch estimate, + this is a form of pitch tracking */ + + if ((prev_f0_bin > bmin) && (prev_f0_bin < bmax)) + thresh = CNLP*0.5*gmax; + else + thresh = CNLP*gmax; + + lmax = 0; + lmax_bin = bmin; + for (b=bmin; b<=bmax; b++) /* look for maximum in interval */ + if (Fw[b].real() > lmax) + { + lmax = Fw[b].real(); + lmax_bin = b; + } + + if (lmax > thresh) + if ((lmax > Fw[lmax_bin-1].real()) && (lmax > Fw[lmax_bin+1].real())) + { + cmax_bin = lmax_bin; + } + + mult++; + } + + best_f0 = (float)cmax_bin*SAMPLE_RATE/(PE_FFT_SIZE*DEC); + + return best_f0; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: fdmdv_16_to_8() + AUTHOR......: David Rowe + DATE CREATED: 9 May 2012 + + Changes the sample rate of a signal from 16 to 8 kHz. + + n is the number of samples at the 8 kHz rate, there are FDMDV_OS*n + samples at the 48 kHz rate. As above however a memory of + FDMDV_OS_TAPS samples is reqd for in16k[] (see t16_8.c unit test as example). + + Low pass filter the 16 kHz signal at 4 kHz using the same filter as + the upsampler, then just output every FDMDV_OS-th filtered sample. + + Note: this function copied from fdmdv.c, included in nlp.c as a convenience + to avoid linking with another source file. + +\*---------------------------------------------------------------------------*/ + +void Cnlp::fdmdv_16_to_8(float out8k[], float in16k[], int n) +{ + float acc; + int i,j,k; + + for(i=0, k=0; k *inout) +{ + std::complex in[512]; + // decide whether to use the local stack based buffer for in + // or to allow kiss_fft to allocate RAM + // second part is just to play safe since first method + // is much faster and uses less RAM + if (cfg.nfft <= 512) + { + memcpy(in, inout, cfg.nfft*sizeof(std::complex)); + kiss.fft(cfg, in, inout); + } + else + { + kiss.fft(cfg, inout, inout); + } +} diff --git a/DMR2M17/codec2/nlp.h b/DMR2M17/codec2/nlp.h new file mode 100644 index 0000000..f480b24 --- /dev/null +++ b/DMR2M17/codec2/nlp.h @@ -0,0 +1,87 @@ +/*---------------------------------------------------------------------------*\ + + FILE........: nlp.c + AUTHOR......: David Rowe + DATE CREATED: 23/3/93 + + Non Linear Pitch (NLP) estimation functions. + +\*---------------------------------------------------------------------------*/ + +/* + Copyright (C) 2009 David Rowe + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the Free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#ifndef __NLP__ +#define __NLP__ + +#include +#include + +#include "defines.h" + +/*---------------------------------------------------------------------------*\ + + DEFINES + +\*---------------------------------------------------------------------------*/ + +#define PMAX_M 320 /* maximum NLP analysis window size */ +#define COEFF 0.95 /* notch filter parameter */ +#define PE_FFT_SIZE 512 /* DFT size for pitch estimation */ +#define DEC 5 /* decimation factor */ +#define SAMPLE_RATE 8000 +#define PI 3.141592654 /* mathematical constant */ +//#define T 0.1 /* threshold for local minima candidate */ +#define F0_MAX 500 +#define CNLP 0.3 /* post processor constant */ +#define NLP_NTAP 48 /* Decimation LPF order */ + +/* 8 to 16 kHz sample rate conversion */ + +#define FDMDV_OS 2 /* oversampling rate */ +#define FDMDV_OS_TAPS_16K 48 /* number of OS filter taps at 16kHz */ +#define FDMDV_OS_TAPS_8K (FDMDV_OS_TAPS_16K/FDMDV_OS) /* number of OS filter taps at 8kHz */ + + +using NLP = struct nlp_tag +{ + int Fs; /* sample rate in Hz */ + int m; + float w[PMAX_M/DEC]; /* DFT window */ + float sq[PMAX_M]; /* squared speech samples */ + float mem_x,mem_y; /* memory for notch filter */ + float mem_fir[NLP_NTAP]; /* decimation FIR filter memory */ + FFT_STATE fft_cfg; /* kiss FFT config */ + std::vector Sn16k; /* Fs=16kHz input speech vector */ +}; + + +class Cnlp { +public: + void nlp_create(C2CONST *c2const); + void nlp_destroy(); + float nlp(float Sn[], int n, float *pitch_samples, float *prev_f0); + void codec2_fft_inplace(FFT_STATE &cfg, std::complex *inout); + +private: + float post_process_sub_multiples(std::complex Fw[], int pmax, float gmax, int gmax_bin, float *prev_f0); + void fdmdv_16_to_8(float out8k[], float in16k[], int n); + + NLP snlp; +}; + +#endif diff --git a/DMR2M17/codec2/pack.cpp b/DMR2M17/codec2/pack.cpp new file mode 100644 index 0000000..8382f95 --- /dev/null +++ b/DMR2M17/codec2/pack.cpp @@ -0,0 +1,139 @@ +/* + Copyright (C) 2010 Perens LLC + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2.1, as + published by the Free Software Foundation. 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 Lesser General Public License + along with this program; if not, see . +*/ + +#include "defines.h" +#include "quantise.h" +#include + +/* Compile-time constants */ +/* Size of unsigned char in bits. Assumes 8 bits-per-char. */ +static const unsigned int WordSize = 8; + +/* Mask to pick the bit component out of bitIndex. */ +static const unsigned int IndexMask = 0x7; + +/* Used to pick the word component out of bitIndex. */ +static const unsigned int ShiftRight = 3; + +/** Pack a bit field into a bit string, encoding the field in Gray code. + * + * The output is an array of unsigned char data. The fields are efficiently + * packed into the bit string. The Gray coding is a naive attempt to reduce + * the effect of single-bit errors, we expect to do a better job as the + * codec develops. + * + * This code would be simpler if it just set one bit at a time in the string, + * but would hit the same cache line more often. I'm not sure the complexity + * gains us anything here. + * + * Although field is currently of int type rather than unsigned for + * compatibility with the rest of the code, indices are always expected to + * be >= 0. + */ +void CQuantize::pack( + unsigned char *bitArray, /* The output bit string. */ + unsigned int *bitIndex, /* Index into the string in BITS, not bytes.*/ + int field, /* The bit field to be packed. */ + unsigned int fieldWidth /* Width of the field in BITS, not bytes. */ +) +{ + pack_natural_or_gray(bitArray, bitIndex, field, fieldWidth, 1); +} + +void CQuantize::pack_natural_or_gray( + unsigned char *bitArray, /* The output bit string. */ + unsigned int *bitIndex, /* Index into the string in BITS, not bytes.*/ + int field, /* The bit field to be packed. */ + unsigned int fieldWidth, /* Width of the field in BITS, not bytes. */ + unsigned int gray /* non-zero for gray coding */ +) +{ + if (gray) + { + /* Convert the field to Gray code */ + field = (field >> 1) ^ field; + } + + do + { + unsigned int bI = *bitIndex; + unsigned int bitsLeft = WordSize - (bI & IndexMask); + unsigned int sliceWidth = bitsLeft < fieldWidth ? bitsLeft : fieldWidth; + unsigned int wordIndex = bI >> ShiftRight; + + bitArray[wordIndex] |= ((unsigned char)((field >> (fieldWidth - sliceWidth)) << (bitsLeft - sliceWidth))); + + *bitIndex = bI + sliceWidth; + fieldWidth -= sliceWidth; + } + while ( fieldWidth != 0 ); +} + +/** Unpack a field from a bit string, converting from Gray code to binary. + * + */ +int CQuantize::unpack( + const unsigned char *bitArray, /* The input bit string. */ + unsigned int *bitIndex, /* Index into the string in BITS, not bytes.*/ + unsigned int fieldWidth/* Width of the field in BITS, not bytes. */ +) +{ + return unpack_natural_or_gray(bitArray, bitIndex, fieldWidth, 1); +} + +/** Unpack a field from a bit string, to binary, optionally using + * natural or Gray code. + * + */ +int CQuantize::unpack_natural_or_gray( + const unsigned char *bitArray, /* The input bit string. */ + unsigned int *bitIndex, /* Index into the string in BITS, not bytes.*/ + unsigned int fieldWidth,/* Width of the field in BITS, not bytes. */ + unsigned int gray /* non-zero for Gray coding */ +) +{ + unsigned int field = 0; + unsigned int t; + + do + { + unsigned int bI = *bitIndex; + unsigned int bitsLeft = WordSize - (bI & IndexMask); + unsigned int sliceWidth = bitsLeft < fieldWidth ? bitsLeft : fieldWidth; + + field |= (((bitArray[bI >> ShiftRight] >> (bitsLeft - sliceWidth)) & ((1 << sliceWidth) - 1)) << (fieldWidth - sliceWidth)); + + *bitIndex = bI + sliceWidth; + fieldWidth -= sliceWidth; + } + while ( fieldWidth != 0 ); + + if (gray) + { + /* Convert from Gray code to binary. Works for maximum 8-bit fields. */ + t = field ^ (field >> 8); + t ^= (t >> 4); + t ^= (t >> 2); + t ^= (t >> 1); + } + else + { + t = field; + } + + return t; +} diff --git a/DMR2M17/codec2/qbase.cpp b/DMR2M17/codec2/qbase.cpp new file mode 100644 index 0000000..a94ef46 --- /dev/null +++ b/DMR2M17/codec2/qbase.cpp @@ -0,0 +1,247 @@ +#include +#include + +#include "qbase.h" + +/*---------------------------------------------------------------------------*\ + + quantise + + Quantises vec by choosing the nearest vector in codebook cb, and + returns the vector index. The squared error of the quantised vector + is added to se. + +\*---------------------------------------------------------------------------*/ + +long CQbase::quantise(const float *cb, float vec[], float w[], int k, int m, float *se) +/* float cb[][K]; current VQ codebook */ +/* float vec[]; vector to quantise */ +/* float w[]; weighting vector */ +/* int k; dimension of vectors */ +/* int m; size of codebook */ +/* float *se; accumulated squared error */ +{ + float e; /* current error */ + long besti; /* best index so far */ + float beste; /* best error so far */ + long j; + int i; + float diff; + + besti = 0; + beste = 1E32; + for(j=0; jWo/PI)*4000.0/50.0)/log10f(2); + x[1] = 10.0*log10f(1e-4 + e); + + compute_weights2(x, xq, w); + for (i=0; iWo_min; + float Wo_max = c2const->Wo_max; + + for (i=0; iWo = powf(2.0, xq[0])*(PI*50.0)/4000.0; + + /* bit errors can make us go out of range leading to all sorts of + probs like seg faults */ + + if (model->Wo > Wo_max) model->Wo = Wo_max; + if (model->Wo < Wo_min) model->Wo = Wo_min; + + model->L = PI/model->Wo; /* if we quantise Wo re-compute L */ + + *e = exp10f(xq[1]/10.0); +} + +void CQbase::compute_weights2(const float *x, const float *xp, float *w) +{ + w[0] = 30; + w[1] = 1; + if (x[1]<0) + { + w[0] *= .6; + w[1] *= .3; + } + if (x[1]<-10) + { + w[0] *= .3; + w[1] *= .3; + } + /* Higher weight if pitch is stable */ + if (fabsf(x[0]-xp[0])<.2) + { + w[0] *= 2; + w[1] *= 1.5; + } + else if (fabsf(x[0]-xp[0])>.5) /* Lower if not stable */ + { + w[0] *= .5; + } + + /* Lower weight for low energy */ + if (x[1] < xp[1]-10) + { + w[1] *= .5; + } + if (x[1] < xp[1]-20) + { + w[1] *= .5; + } + + //w[0] = 30; + //w[1] = 1; + + /* Square the weights because it's applied on the squared error */ + w[0] *= w[0]; + w[1] *= w[1]; + +} + +int CQbase::find_nearest_weighted(const float *codebook, int nb_entries, float *x, const float *w, int ndim) +{ + int i, j; + float min_dist = 1e15; + int nearest = 0; + + for (i=0; iWo_min; + float Wo_max = c2const->Wo_max; + float norm; + + norm = (log10f(Wo) - log10f(Wo_min))/(log10f(Wo_max) - log10f(Wo_min)); + index = floorf(Wo_levels * norm + 0.5); + if (index < 0 ) index = 0; + if (index > (Wo_levels-1)) index = Wo_levels-1; + + return index; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: decode_log_Wo() + AUTHOR......: David Rowe + DATE CREATED: 22/8/2010 + + Decodes Wo using a WO_LEVELS quantiser in the log domain. + +\*---------------------------------------------------------------------------*/ + +float CQbase::decode_log_Wo(C2CONST *c2const, int index, int bits) +{ + float Wo_min = c2const->Wo_min; + float Wo_max = c2const->Wo_max; + float step; + float Wo; + int Wo_levels = 1<. + +*/ + +#include +#include +#include +#include +#include +#include + +#include "defines.h" +#include "quantise.h" +#include "lpc.h" +#include "kiss_fft.h" + +extern CKissFFT kiss; + +#define LSP_DELTA1 0.01 /* grid spacing for LSP root searches */ + +/*---------------------------------------------------------------------------*\ + + FUNCTIONS + +\*---------------------------------------------------------------------------*/ + +int CQuantize::lsp_bits(int i) +{ + return lsp_cb[i].log2m; +} + +int CQuantize::lspd_bits(int i) +{ + return lsp_cbd[i].log2m; +} + + + +/*---------------------------------------------------------------------------*\ + + encode_lspds_scalar() + + Scalar/VQ LSP difference quantiser. + +\*---------------------------------------------------------------------------*/ + +void CQuantize::encode_lspds_scalar(int indexes[], float lsp[], int order) +{ + int i,k,m; + float lsp_hz[order]; + float lsp__hz[order]; + float dlsp[order]; + float dlsp_[order]; + float wt[order]; + const float *cb; + float se; + + for(i=0; i Ww[FFT_ENC/2+1]; /* weighting spectrum */ + float Rw[FFT_ENC/2+1]; /* R = WA */ + float e_before, e_after, gain; + float Pfw; + float max_Rw, min_Rw; + float coeff; + + /* Determine weighting filter spectrum W(exp(jw)) ---------------*/ + + for(i=0; i max_Rw) + max_Rw = Rw[i]; + if (Rw[i] < min_Rw) + min_Rw = Rw[i]; + + } + + /* create post filter mag spectrum and apply ------------------*/ + + /* measure energy before post filtering */ + + e_before = 1E-4; + for(i=0; i Aw[] /* output power spectrum */ +) +{ + int i,m; /* loop variables */ + int am,bm; /* limits of current band */ + float r; /* no. rads/bin */ + float Em; /* energy in band */ + float Am; /* spectral amplitude sample */ + float signal, noise; + + r = TWO_PI/(FFT_ENC); + + /* Determine DFT of A(exp(jw)) --------------------------------------------*/ + { + float a[FFT_ENC]; /* input to FFT for power spectrum */ + + for(i=0; iL; m++) + { + am = (int)((m - 0.5)*model->Wo/r + 0.5); + bm = (int)((m + 0.5)*model->Wo/r + 0.5); + + // FIXME: With arm_rfft_fast_f32 we have to use this + // otherwise sometimes a to high bm is calculated + // which causes trouble later in the calculation + // chain + // it seems for some reason model->Wo is calculated somewhat too high + if (bm>FFT_ENC/2) + { + bm = FFT_ENC/2; + } + Em = 0.0; + + for(i=am; iA[m]*model->A[m]; + noise += (model->A[m] - Am)*(model->A[m] - Am); + + /* This code significantly improves perf of LPC model, in + particular when combined with phase0. The LPC spectrum tends + to track just under the peaks of the spectral envelope, and + just above nulls. This algorithm does the reverse to + compensate - raising the amplitudes of spectral peaks, while + attenuating the null. This enhances the formants, and + supresses the energy between formants. */ + + if (sim_pf) + { + if (Am > model->A[m]) + Am *= 0.7; + if (Am < model->A[m]) + Am *= 1.4; + } + model->A[m] = Am; + } + *snr = 10.0*log10f(signal/noise); +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: encode_Wo() + AUTHOR......: David Rowe + DATE CREATED: 22/8/2010 + + Encodes Wo using a WO_LEVELS quantiser. + +\*---------------------------------------------------------------------------*/ + +int CQuantize::encode_Wo(C2CONST *c2const, float Wo, int bits) +{ + int index, Wo_levels = 1<Wo_min; + float Wo_max = c2const->Wo_max; + float norm; + + norm = (Wo - Wo_min)/(Wo_max - Wo_min); + index = floorf(Wo_levels * norm + 0.5); + if (index < 0 ) index = 0; + if (index > (Wo_levels-1)) index = Wo_levels-1; + + return index; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: decode_Wo() + AUTHOR......: David Rowe + DATE CREATED: 22/8/2010 + + Decodes Wo using a WO_LEVELS quantiser. + +\*---------------------------------------------------------------------------*/ + +float CQuantize::decode_Wo(C2CONST *c2const, int index, int bits) +{ + float Wo_min = c2const->Wo_min; + float Wo_max = c2const->Wo_max; + float step; + float Wo; + int Wo_levels = 1<Wo < (PI*150.0/4000)) + { + model->A[1] *= 0.032; + } +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: encode_energy() + AUTHOR......: David Rowe + DATE CREATED: 22/8/2010 + + Encodes LPC energy using an E_LEVELS quantiser. + +\*---------------------------------------------------------------------------*/ + +int CQuantize::encode_energy(float e, int bits) +{ + int index, e_levels = 1< (e_levels-1)) index = e_levels-1; + + return index; +} + +/*---------------------------------------------------------------------------*\ + + FUNCTION....: decode_energy() + AUTHOR......: David Rowe + DATE CREATED: 22/8/2010 + + Decodes energy using a E_LEVELS quantiser. + +\*---------------------------------------------------------------------------*/ + +float CQuantize::decode_energy(int index, int bits) +{ + float e_min = E_MIN_DB; + float e_max = E_MAX_DB; + float step; + float e; + int e_levels = 1<= -1.0)) + { + xr = xl - delta ; /* interval spacing */ + psumr = cheb_poly_eva(pt,xr,order);/* poly(xl-delta_x) */ + temp_psumr = psumr; + temp_xr = xr; + + /* if no sign change increment xr and re-evaluate + poly(xr). Repeat til sign change. if a sign change has + occurred the interval is bisected and then checked again + for a sign change which determines in which interval the + zero lies in. If there is no sign change between poly(xm) + and poly(xl) set interval between xm and xr else set + interval between xl and xr and repeat till root is located + within the specified limits */ + + if(((psumr*psuml)<0.0) || (psumr == 0.0)) + { + roots++; + + psumm=psuml; + for(k=0; k<=nb; k++) + { + xm = (xl+xr)/2; /* bisect the interval */ + psumm=cheb_poly_eva(pt,xm,order); + if(psumm*psuml>0.) + { + psuml=psumm; + xl=xm; + } + else + { + psumr=psumm; + xr=xm; + } + } + + /* once zero is found, reset initial interval to xr */ + freq[j] = (xm); + xl = xm; + flag = 0; /* reset flag for next search */ + } + else + { + psuml=temp_psumr; + xl=temp_xr; + } + } + } + + /* convert from x domain to radians */ + + for(i=0; i. +*/ + +#ifndef __QUANTISE__ +#define __QUANTISE__ + +#include + +#include "qbase.h" + +class CQuantize : public CQbase { +public: + void aks_to_M2(FFTR_STATE *fftr_fwd_cfg, float ak[], int order, MODEL *model, float E, float *snr, int sim_pf, int pf, int bass_boost, float beta, float gamma, std::complex Aw[]); + + int encode_Wo(C2CONST *c2const, float Wo, int bits); + float decode_Wo(C2CONST *c2const, int index, int bits); + void encode_lsps_scalar(int indexes[], float lsp[], int order); + void decode_lsps_scalar(float lsp[], int indexes[], int order); + void encode_lspds_scalar(int indexes[], float lsp[], int order); + void decode_lspds_scalar(float lsp[], int indexes[], int order); + + int encode_energy(float e, int bits); + float decode_energy(int index, int bits); + + void pack(unsigned char * bits, unsigned int *nbit, int index, unsigned int index_bits); + void pack_natural_or_gray(unsigned char * bits, unsigned int *nbit, int index, unsigned int index_bits, unsigned int gray); + int unpack(const unsigned char * bits, unsigned int *nbit, unsigned int index_bits); + int unpack_natural_or_gray(const unsigned char * bits, unsigned int *nbit, unsigned int index_bits, unsigned int gray); + + int lsp_bits(int i); + int lspd_bits(int i); + + void apply_lpc_correction(MODEL *model); + float speech_to_uq_lsps(float lsp[], float ak[], float Sn[], float w[], int m_pitch, int order); + int check_lsp_order(float lsp[], int lpc_order); + void bw_expand_lsps(float lsp[], int order, float min_sep_low, float min_sep_high); + +private: + void compute_weights(const float *x, float *w, int ndim); + int find_nearest(const float *codebook, int nb_entries, float *x, int ndim); + void lpc_post_filter(FFTR_STATE *fftr_fwd_cfg, float Pw[], float ak[], int order, float beta, float gamma, int bass_boost, float E); + int lpc_to_lsp (float *a, int lpcrdr, float *freq, int nb, float delta); + float cheb_poly_eva(float *coef,float x,int order); +}; + +#endif diff --git a/DMR2P25/DMR2P25 b/DMR2P25/DMR2P25 new file mode 100755 index 0000000000000000000000000000000000000000..76973af226e22e15182cbd92de45e7c82c6c5d40 GIT binary patch literal 2793932 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

Vjz3F zsXRYqmzY=vF_#afESz}cnz0+)O>(PUhM%wH_AFCqd0+hdn9DLx9XT>Q2#*0KncE5< zpNZ#|IB~AbDX&b6<>jPxVL>+0B>cNeblYI4) zdyIUO_dAXpIq-qC!~P(G3GcAO);)yXVuuMs{&JF~jwlcZJ{xWXL z$9KpBEi%Kh?!Xg-8Am>-=bVXbu^%@(>|c{#+GFm3!sFMEe5g(Z>|p8?yMjDakjLMU z&b65KXZ@z`c%P{RE1kUWumh3Lr2W>GUQX$9CmxyTqYWIW^99ZQWW0*_RfIEUUPgZ5 zyxj>m_{hYJ@*<1V<{|1e&d^-5Kgc#*wICl^jUU6n@e z^hfGvmkqst4{5w5+2E$|YMUmKu!ERgCYh^qYU zC(PEP^ra4+43BAKvzL$ zTsjDCLGN?v66jj!pSg4?bOib}mo9^DgnrqjL(oy^-7eh+dKUB#UAi1P2K~HC_k~^n z{ftXjK(|0Y4PA*{ZTm_2Mebz`-Dj7YeRgZOBfHpo&c4PxXAdFFH{7^Gv9}TTt1dkZ zx*hsUE?ot^4*H8OeH?Tr^dl}k9C|bK!!CV1^j7ExUAh{2JM=b}J^}hs=zCoHMCiw% z?{eu8&^w{;bZHCvDd^jwD;Sp|TJuJ_ZPocM`lZuO=;s02!d-u%ucf!zjVaoi{36Lr zgf{C7PtR_j){!1PIhpCGU!0Z+)K5!)%i53)M1HA$k?}<`_8;h7CHbOhF2~25cY9k88{v+1y2Tp zsW*D-QoC(3mqAd!CCG6x4B2WJe3B?oRYO}Rf3r<%I)SshtlWK1^5 z80d?1bR02*bJfV_PRdr8@6@j1w5t}z1kGO|;%Hp-n^-;RX0G#@GlStRcF5X7pX%CQ zk?P8Z2@`5zE~0;xnmL4Bxc)q!xwFc8l`(pYT}k+`wc9=pI+UVLsF#7z!=VR(!_r;Z z5%3tyoH;s09?e2{T)m!aMt6=S%m{dlhR5-Qt%V*8k74krh8_of0yqjD6X02&xf8YUa_w1Y{PkaiM-yRY!y^WdDTJL5-2jh9c$^J=8T2{e zx#Xi69@F7*)lnW-*MHKOGZz!)DtI)*<9x!lLZ1r{!rHT-mq1?tUI>pB@VEpX*L!$e z29H&QxgH)X;4zo5tD!H12Vw1b(CyGo;Cy)83Xdz`vDU+50zB3eW-UB!g~!JTy8(JW zJP2!F4c!rW)oy0p8e|;aJ|n-j@`XFI4`BC$Vbhh}hCP6taU{D1dl0+&Z#VW5?6ugt zu$N+wV82uDw8=8)JFthqDDIuu`(U4ieLePa>@n=0#NHSC0_>l_-m<4F8)s}=tGtrO zTfob}Pk@($>%axzt>6{lC&4Sh+rX>91h^1X*$ZX%mi0O2?(6ZpkT4$yF9O@Z+2C^U zVsHg`3Ahrx6pVv0@CI-WsJbcCiMK933-7D&JC`sE!6^7Ka4L8;I1OwDr-Lov3~&)R z6TAjI4^-PJv>9((Sq<;m_%#sbV(?V(67V$eQt)&z1~!6oz%#(P;F;h&@GMYmyU?b+ zZTTX2pN-!*!khz+2hRmh2BTmdI2AkvoCZz+r-Kv08DIod-z)SvZ(kb??+N&wNSKM> z2rvS&eA6N?d!7?xahQJ`$2P^^0!BVgyB&wXX}n2yt42vVa$*{ z9({WMmE@(C_4owR(z;vg?{%c5b^S!#!njr9b~A2;HOp45`=9fh8cYPE{lDfeXHIJ& zzlr?5U+Z1%%Oleb`h&|2H748yVK*R@^QVc7F)TINaY`Som9b|CirTDB|OAA2xz|3~CHoN|S%1pH&n ziI>%DJ@;wGU+o)%7JCB_f7Sx|d02CBnKK8+*7srl)cQqhkZ`zzHr2sAyw4t%>T>4V zD%QdSp+}pJ>~Yu!VIK}^E=C98%;PK!?;H$|Vel9MkJ0cro^Ye!p}BS};j5u1!J`)Y z3E0Phnu`lOo`=VY@E8S;3GkQ%kCO;@3OqE|o<{hw&{N@YI`&%ZjiBb@0*}wbV;nqA zfydeKm z^!C}!@S2bP9Q-Z=uR6+O;rbSMoC}ZX@VE*d%+aK?&%Oj67s5k(i&@Ys;L(cx0_;n` z>peVBwcmLmJT8I9_3&VhW-Q&Oxzm|vR}p?5^jdhV#@>Xz9n?JR%Ay{%`kC|LaRofq z!UI3%f_=*Whs>_Uo}< z1b!Tx4Yq+7gUi87z!l)7;7TwC#=$w@4d6H7aW3|&ut&j#;8gHq;56`Ra5~rw&H!7$ zncyPuJn$M2o!fy1?6a|-3SJDJ23`W54qgg2f-&$6a1MATI2Sw%oCmIi$2ja~V;>Km z1D*_?3)X>A@Dy+=I02jnP6Vfe5pV{02|P~3J^}j(a3W}d5pX0}4~_ySf!b3{25Z0u za13}VSO<^6*hgTm1TAm~I1(HRjsk~)qrob$20RWN0}cmI0?XkM!XC!n2OKCja1huR z91K=~m0&+`2-qJS3Jw5=f%_S!wO3@E&DBYt5Mys*&?T9BF^RPHBv+ki4r)L0C-x(S zJ*4)DzG#9yVj>%4A2x!qZbBrHtxB^;gg(0`!5%S@Jq}uXx~sYq+3ORD>~Lu9>DI;* zS?Sh}hwcl#iMV0bpw-aM9xeivUeE%y7aR#{zc>o?fulj~4YkKC0l$Jw z>(tlLS!&*v{7tmmnM*W3D<60KiFq5{PD6T!-H?(_U}{!6f`|PbX`gx5K9+8v0=+=M z?CO9{^XvXZ z_8yncul*C*yIeZI{!e7@bZM>s8{vPuOXv3iiR=cK&hG^h*-yH3em{`N-r~~vJwYOS zlS`K|cDKN96?9oxd-lEPIQH7-nrCvp6Ox&8Ek8Pv=g^IB$c#L;?^oh`qL!ax?BcOLepXJgP^i$BMLl<;OM|C```J@k^e=z^#*L~~2ud*hS zzCnH4+n=vH;lutc9k+Bs!Ppl1h|WF!woj{HIenTwIJ+m2RsVAObdo;Zoye-6soz!5 zAJ;|_S*O22SJEdpg%jBt{ME6?_3>}DB#!ER)W^e=AqbCx-bZ>M>3x*8 z^ginM()*~tOYc*f%IkeHlt;R2>3AyXqw3Sr&s0!0_34pCecG$<(K@T3^U<12eNs9f z^=;{V)VHPcQQ!9Jd(@Yu?@?cuzDIps`X2Rd^=Zj<7kyNH*hIJ374&QM<*kR099&92 zUaEd<%|w4oKlZ5~|E{PXPfdRd-C+f5!a_fO-M2f_AKi07=cD!YRMIG{uOEfC*4NW; zE3B_~;8y7SdyCfBp;RKPF(;&PKgF6fcDHR>FxI_UpQUrA%ji48xjC*t44013(HX|j zeXt(#L34G1vz(tGhZN&+G8Z+S*@d*#goRF!vo|Y^4iT9&qVsMFciKQ+)n(eIiIuWn-NR{_9>VscFz0k1(=1{+rT*34z9x_uy=#^W42>|9P9y~0G|S1 z1ovR}Vye=e_SRHh@BVtY(|!ZDG-2KY4}*uuQ;2a`V=ur1tlHWEg@hv^fN+abo=0PAz<_)o+C zb+eT`bY=@~^|(ojOa{h%bSI~^p_ju3nLGWGo~B;^RF(>Mu(uErX276k$qz{mhI~^<&lj$?8p}| z-@-4(Sb}VB9pUJmv!}vGI?Y=sb0z&_G-oL9BipM$t{Iit>$Fk`E%3EExiLM*E$?_)G zO*|E@1Ubxb-Nv|X`@|P{JV~4AN1v?4UuA7mxhRWI`N#hou78E=-|G6GO#A`FJ3Kfa z?`qe55$?3V+?%fZ0@r;9`B!=m!|z4>R1UwJ7j%&2Pq}V?QF!va3Ae{xx5KU*d!_R2 zuG{Zjw;tR!yKcX6-FD%&&UJg+b$b9eKk0vx^woA=#@$CfcKj;8zKOZv_qpM@HdY>W z-ClRyPQ$I*b$iuy(|JUN>-Lf-Zpd}}q3fpe^uwG_tK7R>w|jBh>$-ibiZ!b>kXWd4TdxqrBoL{rIQxtF|6+ z+Fk{7i_VU#%%`%yd!N4OhEuv(=yvldd$PxEA8wE1Ho@ceI&LxC#(CUc#qCAhYFsy^ zyPS02C`$Kr(%nng;hwm=pc{xg#1mKT>i(j*TZ#KTVLAIhTDB&_O(_c3NVxA1j=L8} z!(B+YCyK)DB;3~t_eb^{p?aNhJzy^wsD8P{o$%O-v9WAyu2TG^WJ0jIAw^q*zkACG=(xX{tL>q@E??E{4vV( ztXrno-^u#|^4|0>$onb(An*T0K8xG`7B}y0ZruyM-O=L#;^XLjK)=vq4OPX8a z>9{%aR*8wG3+pQBEDo`k&>gK?$yWt=(*3VLzIWu{#_+Vzo5lHJZ{g&tMfvI+#GEvk zjVSB%e7^oLg?wrM9pyf#Y03m58`G;}`Fv?#yk$&BI$+IAKN8^#YZ7~xN!*)>%uKJ2 z9C^z`Znq2h*~xxd>1#c%d6GGhy}_KEzrlr_Ove6JQ== zZe;C;9xk>qZBpn>A|KeR(nsD}W&QT82@Rvu6=r^>5Z({1IMT%hBI%4ToN)5ti%hjg zH!zPzQoY)D){yV}kd1|GEM(JzY$UJyU3rCZ`!a5-!>Z>$tj8YevygwDU^w|7<>vn} z<)3_NuU^Q{(fm^`)#tJE-*oK!TlxI2vW~pv3(v7vMSlBM038K;8O|FyPox|rkv+Ym zg7a`=KW37H3uXI?r)+E8vOVr8Tf1AfrXS?XrgG^lP-W9uAa&xDZM0jq`#(~)WahSW zM`!(!(b;cW+cHP2QCUCr;?z@|a>nmSo3!fbul73HZ$)HuxMUPh3y;>9%HyN&`XVvgTW5uG{=`$x3b&lEdCFPlmUHh9|F+I}wnCej zlj{pgXFVe&otM&zX4O`F;osXnW2Je;lMbM--dVE8))|A=QM4W1&CF;Vdt2!t^TL>M z;P-AH_|b=bz_}}quHZa3O`iOe)4v$A=H)oMdoa-QOfEc?JG$KeEo-?wT}E4=-RFXl zhu;iZ73p9skXD;8kwCh{+K?_aS7!pLQE82Hbq$--b&VQNp2^is=}1#=nbqdEZy}?Q zKlRgIUxd4OxK$v>c;5Z~0Pg-{xudHHq&B#Ey${1z;2!)t?j^@?FNJpnX%x~8M1FdQ z(hitJ0=zw6ujrhdGsI-hk36{#&0W78_8*X^^n)5t?n9Qh@t5GQh5mMQZb0V~LceR0 zu3oU`Zrj&_%);mfoxA5(<(xAF_a1sfH|K%Q{vod;^e0&B#~Itu!%!!Vu8=xmAMp!Y z`klgFqNXRWC+ti9N~~vkBk0+x66gct=mWcV*?&flbZVnH7>VgFVls2h>6}%Blexz5 zF7$2N>`v;_P#*Re=u;MEqUiW$gwY?OqdQ!)D}#Qrd^TmA0X@ayPAzdKLo2-Q^Gm#a`G&FdKTZXhmq=@-LW?XOdZTdBj7$U`@E*i9Xt zg#TvT#^bgLw@tW>#BB|3C*#(R+Zx=eanqgfI^6gQkG&MPVR8fC`yKZ;$WIvgsxA&o z&XkFF0qotl*H5_PG4#&^^oav1ug2wfDaTmc(c2x^#032mZKz_m-&A8NUgSPEI0Z8s zvru-%LG@`9O=g-{6N-oU4~0j8r|3b@dcX0`Y35)JxR?AC>nLsVELn${b2N9GmN{AJ zvbifq9p>-8d<=UPcO#XapZk#Ll7?H6J)}D?cP94NX(LmRtNfV5?!;|;AhJH~k4$Gw znv*$^GkbJ|nW(jO%-Q()Vl%TPvD?$W@OkLWX>;^Ly+N75y&9dx`OR~^vuF=fpv99j z|8nNu%zGL~a8tUaP9F9;cIL9-wXVA_k{nEX8R9dn+gLAY-XvW|udcJsr>L_M<|^tb z_u1k3elRP{`xi{14X#5bZ&DXZb5^R;&QL$$&edu6gqcFyxt%oYaGQc#EpBzVt;bDw^UuPq z61QsHl(!UZAc=Vov(#-LZP+(q)?u7+JeIG=uOhof)fIIoxv>&J<(8L?#&m32CR&&$ zDu`2&o^A!w$@>1xN!0(HYD=2SeAcwA-`dFhH8aavBB%E1ORdk&M$W$Qo?c%#M_o|& zawo0D#8Dei-76hq-R|5klAit(Za$5*&8ZLW^=21X`7vXm+2x!?IAb?*kHV8aaVPrC z@lO6C(=EeUnc9KIj>plX4Wph^MwN}{wZj)EJ@SoixqM-mJN}N}oZKv@-1Blgu^rxo zoZ4?dx18R{dGZ!pXZoB0FwbtWt;8L;p|eSC#BC#P8#zE-3RT+nR(&g9JhJgku$?JCN?4e0o2!z<&Iou z!(VAX317*X^`hh6=(_L3T|Cq$E}^XI6ScJer{2xaJD#(Ym=tn(8IwXTFJn^3FxbcU&^iY=`=F-Dly2_=iT>3bdKF+1p9#x;gNcRvc+A+x4 zGa%=qW094YcTn<9ug85o;VgDTG91`lrHb?%1xR&r;bAAZg}7A@D6IuOLySjfqMt;+{2{qoiweN8ONSGn%?(4 z={-w&?Vj|iT^UxpGSv8I(53q@evITUQ^=RrFg&#{?@tWQNc(=XxBy+GIcWi^)$LPH2;B`NNyF*gk`soVhaJHUE2Hy{$o zPVgr({Rgej)KSg~%Gr-Ou|H)PL>UGbm7&p7hQ*Yjg8UcCz?T^u`5L#qDeq4IacNFq z9NJ%KkBn`F@kM<%i1~1gN!ba*ct{#rpU=X6D)tce!aDS5TrFL z!pCX*n{@wz@l<<&5b;7$-m`FjI6=82XN4_Q9O+^iCpp97Es*Y&(kDz){Ui8~qRxHB zus8E%uQA;7N8XS4a3A!cyN`OBhTkOoR?%j@$=X(T%5?^(w?TUAqr2sY&F+lurt5zB zAh0^smF;VFWc4<7fRk?ij`3*jDfgv+RCl^lIp9L#HV}6KaT`5x z?=hIWA&(IqSz0c4a3%$=!e<<_=Zy(@2_yN6xSxOkagINaZ9nAHh z-obnv)H|3qa5}gg)H|3J;7o8OSX|GY@YK5&y!y>+_^)EhUwT{;8Q z+odx>yM~IDd0t*-rmdx_4ejsP;YN80rmFgQn0um zOo6A~(&!zL-qM@_>Mf1l5se1V0`-9PBC%ujJW>NW@OuK!UG2mh5(Z~0PajV3w3b$(4O>y_!7`x`8TI`?2-k*7Tkh6c(9ccP!3wN5C!voCStk;gt z*(#6j+Dga8elF9Wxq1*~8PGzx(v&O3H##^I(3@Pz#E%_03@(&a>ya;0*220iPFZI# zmxo`@uSawb?NQB@)Q!HOkZ|Qvf-KLGT-aNNaSKpRt-)_gug~(m3HIpkqU+p{O-8!1 zw=oB^MoF)V+=mbI1^=z zim=Ageg7D;&=|&6KZE!+_&0gtx4Plm-SC|*z10(cA@NTo{!HSJ!GFFd{t`F*jc)jjE`6^j z{%qo(M*Q=Le-i$edE#H|hQG-Tf4fU>^TeM*{L_hlKJmxmf4L|Ab#C~Z-SBs~^nITA zb;NHZ{w(6x;=jNXf2kXOjT?TGOW*H_Urqcoh<^d`$Kij4C;l=w{8~5sr(F60Py7nv zpGo`+i9a6yD?RbAcf;S}hQHILAN0ik0DZ<;#J`C6C*yyWC;rFX@SkwQf7+!#>xusk z@uv`fHu3B5U+9V7=7wMAhTrVc+dc8$ApY6JznJ)^;QujC{N--=Tix(oF8z=v{)@yv zhxnHee**qjd*ZKf!++8Zf0s)??1}#r@y{jxrNp0zf3qk4N;mv%Zurl*^bSw_$B7>@ zTkRUgkzhE%x`c1!nECazi!&{q6|h&R0kvn)U2)!sXZ1ZE-Hp~a0tOJL4|d%fF9-W_ zS4d|`0oK9gtfh6{fE)Lp`5ptPwl)JEQFsg{yxI;QdB{q4pmvbg9el{+P1dDR;tnP5 z3~)F&i*P3r{sM3W*aSa|bYt+Wfmb2@6met3!H@G0){x)=;?xr73UD0QO5E|pZ6WRi zPu%UqZ6OYRb}Ps`AbTlsCJ|>DI2nu+w~@H*#BKO6Zv7h8!*Sv?5T_j^4C}~!=+9HU zCE%SFm>}*n;&u}E98X+y`DZ4Ga}IGjLBiOZh;trsJ_Vi+UI?n6NFP>iB?H6RmsYao z?$@0RoY0*d%>CNH2;9QmtX*;MkNb(ZSKwZadkA-Z+k!biFcAHGAe{^hPA3QZQ^~-f zRB~`hA{iKxNDeNGCj-Oc$-$*9$-vN-4U~RwIw<|#3~)F&6FeR~53B~y2TuTJf!;pMH>eIoaO;bo))N)r zB(NW-`Mp2b01f~(--f}{z=5FVzd>Lx>s9HX^ghi8t@mkua5NYIYrr5l1}p*f7N!&& z3zmW3C%$u56P=T-Wli=3ZMa`TYh~76agg@hA6<_>mdt#Avc3hudKdaR?7Z`1{khjp zVV6!}Aoi!R4+1UdC$a0k3U5xFbz&{3`}%0^%8fyvzK8bA`A;x%pB&}3|PCw1I zu-Df2f;6u2er5fgj7_hj&j_;j)SI9dba}1l^0fceo1vw=!)-&aR~=^T!#|FHJN|2M zUx&Na>N;BpM((h$<~>!|aHc`O+Q%AJ?suW5k=xIx6Xi!bS^9E9~t6?z#ypi<$Nc`k&ASjmC$?>hJC|B*hw3#0wtGfP-$rl zQMzIC1G`WU1=(AavBpzIJ{x+cqqA~k3m+q$1ZkwuH<%8auy!SGRruGs>D8q=>c1~CuW-*|Xs3hA7>l)csYH%HI-u{| zp%bKk{K4e+md+VREXjP3KkpFM!T)Sb*ws@O^z&+$T4$(lOP}ea$+_uR(hRqtpCui= z-x>)mo#Ht9l*W8tcq3y!Z}42&4;_Xc>Cyq{D(DkjItXn+ALr5~(6!J*T)GrmXGH^D zx(vDzx}Qsjprg=zptY}3870FC>%;pz?<0%Xk>MntIl9*iyL<3|f9FG8X~FI59yiT- zat|{GolIH%lw0G#l;7%IKvOP%pRXy$L_546W7l`X`!bJ`_O;v-3q;Zx>8ARzNBpkE z7(ttwIhu2I?j8o=rFv>1Z`un>p4=tK>uni-q(2W@$;`qqXYz#mk3ou;*VTqy|3Z3G zNN?FO(#z7GYLLY^D|z(J-#3*Wa{4OxJNbjvT20A9we{PJOq`&8pn0 zbG0KM@s!s9dHuSRSN8nmu}?Uedv%n?)TW%y75pIk_Tm1p^le&O>_Z-D_RS-?B6QB3`!r-1F;S%b5du4Dl_)uN3zXXD{-rz|V)D zldjvA^^KFlcrcxEy{$M>3wFcZnwCO&$hj9-Pb|P+la4W~H3b#JEjmNDov;{pD zyUq`4vDaYlhdqLQB=-K;8?m2=JqiwhK3?v$k$$w5zT%r=oq!w$&}Mv+6Yc@-uvRp7 zAa`Vg-bd~C18Y~Nau2*+8J*{m(VyRDZHjCpqfHpq?Xl|AdoHH>4eBlkXMDy2Inz!= zItD`z@ws%=r9*`C5w4HUtH5v6@5uyoHpp0_!mtohp_ts!PDa5y0vFmPMyXastqqpFq^RE1FK66}GHyl^Z+>rtIXEk(bFul(ohZhn199@8cE3Vxg!zjFUwJ8G zThQX%E3%P2_gv16=;JN-+B%0-*u`#G-Lsj&eGJ2R7iF&VkEHzg$G=jNe|F_BNC9}xdba2M~{F7HA<-1}GDU;L)6JcP7fAWz(b8$Q(yt9;bD z`KWR8F%&=9r+D%aArHDAsC-PqKYzdNn=a4%JK;LHlaB+Zm10f%I_D;|QN|X@^RGh~*JIqFOz5rmv%Nmr)Rb6fR%KHe8!?pI zk-21FxNm928NTm+f(&mEoO*fz_c}KoW0F(PidU%T?fA`0Wf9tc;y%jx(YEqAH|!2DMA+8| ztG433b7_UUscQ`DCarON^p$q{Z#Z&~9gaS|U*F9Q@*U%9=5^f<3Q$IU&scet|EB%S z<=`N~y}8=wd}s7XLpnEuxlR2*-#1pBX+087=$oUwe`VcpI%zHJS)c6-AAbw;S~QtS z@hz6x7zopmLO&M83JNH4NoKNGf{Y{Ac@UsL5g4BWHNH!yh z=i__Nl!u>zyF61uS|%!4H|5k98@MAJj(276C7e*>tm2J=R(^Jnk8p(ckSE@I;E56#qmx=GA z?@@>4P4w9@djVl2hqv*orVS{MW67i1@1Z-M-oFK& zNttE%*ep9!7x5^ZYWxF}2%76bsV{@0ipLliTp@um}bE$<}DeXh^ z>^9;kZ(9|YF;MkT)`Hw4)LnerN5&S-vkLnuH|(+Ix2y4+rLxoa1C+5ax9Qsx`u4EW z<(}1nHEy~$xxD(g>FPVU6_MNXV;|`&4W-%UhSM3p#^}@%?tapz3gdKC{-jx$(@U&m zrWOC$^c9s+ZQ+NcF`Kn(;oB3^MajPwf7zw4l5V5MO^Y~#)qc?zI69tk`jOK7!&~rk z!v37L7R!|#xdvmw0@$pD`_& znZg(@IXCu@HgmkrD2#c4^yg*XB;AnpDaQRz+0wT(;`g5N0zJi2IKJCK83|**i+clU zOhG0NKL^oQdd9)ulJ7#^PA}xGJD<0QoxEL+WLB|7`Ex!0ycU(L3yC;WI;H z1@fpO9lo__Z^NxHCKcuw29a`oU(obyVLhV!&duqJpeEd9TglJbci~?f>#{YLmdBDA zNA^kdR>;4EG3*lj3*$fub}P2kse=;ady7*CS2$x>ZH)UnQO;IqYZv0~$S}>iU-Mc| z(x>sd!n*5ClcN683Fe^hgpeO|%;q5#W^+kJs=8L4_oW?a z&VEYn$gaV9$X-U8T9;{l)!ppJX`=zcX*{nXFK-f7?T6np7#{3l9*gB=IFoj-wrr91 zA8q8cVzseMkh1FgMirQFO5a9g{(<)abR;3>va`s8`W)@t*M=;# z7wfBjWv+7EqORLZgj2Z+W!za*zCLdGI_2J-FW&;V~&Bj%?&FziRX8?CtnFZ5n^IN&SwApH{Ef3N!BaW3ChXYGN$m-{w?ea&*QfaEc&d*N39`Qf0pZBhsLu|WDDO* zndrzx`=E%s2a;YzYcI9O*ZP@*mfEb!MP2zvUBg=)-oFWBLVo*Uy!0mO=iHx;aMl;; z8q)6EZ<&{43?BYxev4!)Vf6hlg<+k*_?90Rv=-4@1+71fmF!@zgMOX7a-OHU&{(f| zL-`#{SqkZhe?_c|zB(_*Z$*^XxcU8e@~eDqC%uBcMD+d8-$PzAkWU-N$9mmaqr@2} zBAg*c{;kB9U>-q6W!*`iGk^PT$oX6N7Ouv~srfk|0*|0YIAmbr?4zKox>@H&@3l=! zl6`j*XEhtSqeO{u@6xk$u=*Ojg%2TxyLv^!CpdK zwTBAIUahf_cB%C#`vyA{>jaStJcw7KwL;M7uI*O)y*E`x@;|4eH)QEIjXHYy&eZ`P zZyl75p?Gg6nJBGV@LEg<=5)+I+b+IDI^K5i8|eR+c45&jzNa$%|JW{m4ZlLW*pB^C z@ps$B7|K2k^FD6>Y`ak0|E^uAp42uzMYuw{u;Ls4*V=~VwvFXZIsdk8wBoMsIOg?W z`8}g#qIU5Jn8y4C^K}g45o1#Rje%E>8m15FeZg^R(^1AK^xJw{P>GJaB8`r_p7uYG zZ)b9sZwh*5E8w*6Oa*TJMA z9xSC#m!O-jY{|bVm`>i6=TXm4t}wqP6XX1u{03S|v-&n@DY|LBNs2@&xW~@j%UB6I z?uu-G!ko*yg9#(iUxyQ!62c7*@8Ucios*R>hvpldTj||np&YX)#|xfv{G+!9(i2Pe zl6wt$bnO!>6MR1xotMTitxeROpyMi@k;Z7 z_Juk>(?0Ba($<@YTS;3y8?ZBe=Kg?P_h2Vs{~h)=*Zy1V?b!Pf_Yb^F5%#Gy2X7;P zvcIplDqu)sCTICA$aXTa)p^=N_WJJQFnxXr?CHg50W#u$1)@;RIQ{1IBba`2kX z_=6sqwr9$Jg}e5LS~s$HEk6RyzWPAhUe+C$b(n6Y)!pw|VGZ=yngCgI0dfbLRK6@OTopLY~C)=g^htIQvo#$w7MC;_uAFqIcV~TX;ie z{qKIO%TJv+=k&boq@5tckAACb4|y&AR?$-2q*rWp&$ro!mKS8nn#j@7s|_!;*s~LM zDe_PmS)(~`ous!YoUcg!Vd~gV8(Pv=-)HX3O2_zStvRrhI+D&qYrGlhZhKZsH@bwY zGxenBi;-92Hj;<_)_IYMyc^XXf^lQAFiDsw>HAW*^Sy<68NG)tHLvtG;3j=!1$@Bq z{ll}E z(QotnO}LAf`j7U)+H)&C6M2RE9r-traL78>vqn7r=@i-!WVhho=bjpr^Uyc zG?hi)%k0zg3ildcK@aeXT^fJIE=j+_-Nsk!veYYf!VJunw$c_7$-%w^>*J-jGcFCx zm9;aMths|V*DH3Q<@OBa%LG`5lkY%9{Ekex=N|ji^@JuNyd^ZmHA+Q-Ys*dlYRH}?k^xawO9F}0~_Bz zbsleVcw-)!ZfTFk8N&FAR7YCl6Z*slkw+R`*MZmEwB9A%Ev|h)IGBB`DBVI{e~7#M zMc?6u*P4HOQFyhDrSKQ(JDqxmta(YlvEhp*Ga7@Py+Vw;C(OM|vwX*fIY(nuEp@R9 zemxVv_m6GY z8Awp)az7m&t+?xMn%bz&aSQHqaX*CHOzPrY@O)6=0w$5MOd@wW{1tWq;p$xbBiN^) zgODyneoLT*SAidM!z{!e)|or)_-fon!*?(;F_d5DZjlKV^(C*Pk9s z=5$u2d835#=v|E3`&To3H^QBRcJ<+0nzctoiv1m70%i+$4bf4tjv_p1r`^V!N+g1gZ9J*4XR)`_$|+;4=3;k#@T zjCnFZyVRaaW1Dmi)K7T~zS=A63{2-%(jDs#WJ7{F>3*HD`HEbWaC1TKmX%Y6-0WdG zE1)doE6A_GAMU+V!1knas997t${T*F9VfL@|RqnLgpjs<5kGvL{|EsIPz4xC5|KOdC2-j{QUSW!*ADVZaS1RFY7%2YL~zGy5GBS z+W!fpai=Ti?}D3LUYEg3dHD(Nj0-aIaaQfKHaT-GhuY|FKBRwCMDKLww%;lPK(d$n{ur=Zqoa1=Czo3Add>l<4a9rK8t0}ftTjBlYM-<19y$9O{_K4 zzO@d~_rC%y>-lyHY0$@=^xW^|IBAi-+P8F}KF*J{ZkmC7XOR!}Pn|_8edUjD+Av1N zGRT>=(pGyUdjiFo!CL2Zt$%21`i>22#PI>ow|q+6^76fqJGDl0*FkgvbHKGTFLl{b zzQgTPeIe6lLi9z_*Ir6#>w7y|$3K$Je_LI7{}0k~;uGG{#S>p~zv0F$#1jw2-9lX5 z;oi-+X}Bws_Oss7n)BEC4i7T?8mRggPmR00bEbTAa`%#N^5wW|tyXBuF=Rbfa;%lSUH`gj~UyzItrA`W?X;?KtZ zGIsrT)}B%MJWW3LdvEDG`*PEmV>r{0UeD@U+ zt}c?xbCQKC7rxi*$mLS<@ig{QvnE5^9ZdTPgp&6&<|GHJpGvQ*emc9mGkXK`W2ogk z^aq#aDqFhj#m;%uWt_ddUZUT&rY)80taT;fbf!^7e^vX@8E7B!tKYcRc-DlRy!~_% z^oy*soO+?W-f^%{FWzxb_;M$_*F2LSUo<8ak1-lsG|p&z zDPzphnx!Z525XzU$Ukcr{GO_R3Ec_h2{ZOk7V0A#h&|J*F;RWI&NJ>@_SYljfBhAD z2d6IbZICx0j;yC6>j%|l%z4?Rrqi|wr})|@>U%P+xHXX9lso^b?vEu4r;XAcB$I+H zN|43rq*;)`Z1^b8I`>xlQC_tVsK)(1`p;5y3g0Gur|+hv1JJm2H6}T^0{=2-t;@aj z^aA03hGD)vu!cE(7v@DwSo6C(&uh;*1zO*_S_&pGdokKCYcH#NS)mr@{uFJag?C=v z`?!a--8OMditp>CbpPsd&a;FIbBtq0e|y81WIfhHJ4&$Th%pB{?QcH)S7)_9Wskv{ z2K|oKX8QdN-fr|((Vuh<$9*fUjT{-MY}L4bzJ|M=-Mi2)CG}mpToCuSDWBE^zs9eM z`jDIV`*lh~XBdp92Q&xh&d9sO36h5TZsFT?+NV7u_Za0gTb(x&`mX5}xY17>`Ti$q z$gglODvsZJ%t!7labEch;ne57zfrM7yvd973I*MR^aufy%*`v~9LUupyi&uxgP*wT zFTN3{_bQD}Kh1w5PH!Wk(lML3@D&C1E{y8$^{#MAw9?dkMQS^Wm%@wjOpP~cq& zJqGg_@_COodOxV|ut_hgePJWA3Zjn~z&&n_gJJd<+=EBQz;8!EJ2DINTb8WVnphY3 zu={Zz1U-*%erV?P++gTSp##wR9pg&qi=czhCD22l&xbC7E`=TnJsr9fx(s?4w7%(C z1|5Q~g4Vhv1lZBUP_@_gNS_oqA2YWYDDXtsd`m?s$S`%Ioj;O#ywq*Zqyg1{;0cm39ogR?h1PO zd>;3mnBY$tbJWhc|2f62xBi}bYeojgsyDuu_>p>>PdIPA&4KpT+r`k{dbR= zz4bN~+FNgDLl@VZ?!X_b-ne&KJ`DM3Zc|?@uD4eycj|voZ#%o+U|ipBmr{SKJBzw= zejkdttQMC;i1XXsp8ESLb>fx#OwxAx}|X-N0!Cyc&T`YXP>LAjmzDI&RYW>8E|VXXU@#af;4jr5l^y!0(_eG^UR?X|f5 z0=GhXhV=GA+n5BhZ;+w?c*j7^E0S{!`P8|O<`(Iuzf)okY$v?GZ%p6T<2fmNhSPQT zEu8s$BOJ>%WB+`%g*&~n+ec{_yFmIK%XP-+`IWh4blt?o_^a{%l9O z;+c;0=6b$+E@O@2d)I@UbR`o%XV?Mqk}OGP^p-$#sJ;z+2w7$2x~sM>>v<&&S=5(Y&G1JJNz~|F7_K-h07Q-+TWAJjLq+55FKh zjBiV?;;dU3Fdw0-1CESY2%YJ?52D;nl;3x%$~^c(Sr0*0&#tG;>(iSDE<)xQPnk6j zddn=GklrL2j~oj1v5s;k4dp=Q|LSxLZGpFwWQ z-S&X^|oHW0~%(|tW4scs!jJzPDuMwb?MTUJ=`^{Ntg33E!4w2o75OH8r}L;neyb= zbl)EM;8z|wDIK!LrTZmGn>tsRzL-+%eCuU!3FzaVRsXQkqaR?nA3a!agn7R)SZ_-E zGcE?+-Ekjt-+}Hg_)HSB6Y~P*b<8^$^F^Pj#MEFKFf%Ysm{v?XW*uRC-Q%*Rn{!;o z3FkftXF9%~le2w$@^0EU=uQydiec@McVjHzeO%s6Z?6@XJ6#8S$?@5K$vmyMt6E!Mpu%9gg|X-Ah3{lDzJ zf1H$Mz5jpDuie?*aT#RM6*swo1y)%-Lt>#)4r#?nIt^%LWi<#Y8rfLXG2_(0?gB19 z8WlZe8e{&*lxi(IQJD@(MTLb*9xJQsp5cb&M`kB0Pg#7PulvU`Y)kU#bI$pG|2U6% z+>iUZueq-G^}gP}uJ`r3v)YvPznRzB7b$jCqecH)^GgwPTD95u-`n(Em|Be&{O_&$ z&P}d1=KSvp-?Akq+J|h(zdWmP$8zoK{I?bvTKk!pbqkLtN36Y`5ZIHbWTLnOAD1-% z75JIuF%wNPhisYCjLtNRW#D_B|M^akCZ0o<2urRKC1e5Fi4~@r#*EG#n_%>R6Zu-R zokn{cqx_#hKH_GIIi|un9MGkex``heSCzebJ-CPS{Qm^*n}_2Z$bLU~3+KoHvJOt# zd)AnqMwzO^1k+FgKjd5GYCl?{?AIv;-U;GjMeWZ-zV#GYBZw@=i`pa2+yyu`lP>AW z@>HX~L^Ji!I$+BX&$r}RYn&wGNuETd)2Lt4W*Bdvo-NR&k*6h1dcJk$TPyEl$glH? zlt(%erQh3X3)h}8I#X>Vy}0+@h_#t#JCEUcp2zw;I>FP)GlORi&qX|od6x04<=H?w z$xAelmm$4CCPn)Qav{A4b)a4^Jee;}swM+j^z;H*JSLDu>4o$pQTE|z&0(ltI%`F+ zwa-@a9?SdRztA`LL$uod_fPo_^+@X%l}F>((&dJd|IIknKIw5}!2f3KZb;8`mW%Ru zdVwA_X8rF_FXB1>JJgGL_94Ca+RqN@#jfEph95Xt@`WtLvf`K4#2`0$$(Z;FzY2UC z{|u_Q?dyT;UIVfo;Yq=JwSx^_o(Y~T$VSGIfoAebXC$Z6heqC#rv~!G_&*4PeE24T^{xBc(>D;a-1wtwyY5$iUdO*{|rZ09jN&-27LVefg`f_EqH89e9l zT*Lp8aSQrHkcDu(L^9M=^5Z1qva8KS|ND3PMwT0l|E;km$#P5C|7JXR$mWOb0`m;} zXdA1I6+g``zO7;Qo_%qitfmJ1G(Xcf_BoWpf7dsv6XZ>|D*{zq^L);eMlyC&rB$jzx*j{cZTCf zd-HbWF_xy>3NlCe5%5VEaLEeiDW^?w44w?{Y~6Q`aGs~YW5^@k z#RA@`y^>5d6n$QK-^gKOq3#(`-az6zV5qDW<7YwP9#_NKe7_f)_o(7 z(aNE3$x7Ice!Y$t%izV@VZ12N?-?r_XG`~?TN+yD-~oJy8}Vn7XM-dk33xC2q;@lb zP4fCQ#7P#^Rwlur3A!}ctntrOym@5F>(A?Oco#T4I1C5*v6^FkKzLBDWFa;X*xC{{ zs^H6NyaInS_^~#78Pc5|F7X0ka8MiW`51&{N9AL-7BtpOJ8m>Cs=X=Gy!JQ6cf1Uo z{0_H0hrP?4hA+anP!T(Z?M>(Lg~`_pES=*j*;m`0E^u}#?-VkZtl$ff-}8+rs|6h8 z=g8lYy*#F}0~oA_A#bQxl2Q3kx+g`xu5)qFFeW+M_#r4@&{N`FlKxpuZxk_ zX9gnHE}j>7UV0#6C3*DL)6UaX_dPQR&*hyD!iBp3i$Qn;@4M>aHxu3-d_P+ke}HfV zxzc>T)=5P&Q>)T{#U06ake!r&r!?#p^lV~m!2f0q`e8n??5f5stfZ2hqI-^}6ld z*MY7!=Y2R@>mj=x&HCS(hm`Jp)q}Os-D@ARgSY>L`(cO4{fo%G#(}(kS{ZqV{}CJA z8$jN(e%l-`Arr_}GIN?~PIs9o@*STx^9x*Zd?a()f#T3)ODJDf?+{T=FmXiO?Y{y8>#&Cz4l z?p0T(H@ao=^zzpC48n27;+8P}X6600I^Fp`!Z))v;ERKiJZDQXF0OE+bsNw6LCu?9 zgPa!_YgO3>{-qhSPg557xf-*l{b1byYt1U)&sq@9dtm&Ya~y%kKB{r@)pt%vSkFL< z7kESi{&QGk;AqY-nx(!u_AdXszcyBLeuIQH|EE3c&u6zdkZ@cC`4Juk#}zy$D9D?fiQQ}Y*D7S#sRwANm(7d z_o__$c6To8i|4ZT;GG{>SG}IG@bmbNSJs+|oXyn69HREwTFfts2Wi4_!s3N|tfVP% z{`a%IH7-~p-#W%cO3Y)jX0o!js{Nj4!v}q9O=h>knc%!C=<#e$b?!0mAYS{hygNij z*t5qtDr-=V{6A~JSsQX;P5UR`%3b!NnfiAcFMjty_1|+fhRK@?dFEK{b)5Mx`rYid zQm)<^-WsdB2z>Ov?hn%bw+7+GyDRuVlkw>u<6Hc>8X9Vh`aQNkf2%pb`-yw%&6lL_ zg7>M7F^^x8hqnKWS=)KPNW4Y-gV5aDFKFnC!k>$aYpbouNwL7V`CBzl!5oWukT$Bd z8q2IT4;7wrzc_sda{|XZiTujZN%jTajU3TO9k;~U=$?=**DflquVyu81dK=sBl|Eg z;yw)KT<@B_V^5rM`9xvW=vMmbA&hQdoR(uQr?kEr6%61-dILOif{_@4are9(dlJA% zW_w3B;fLN^^zk?VEv8&nX0CiiwZXY@Pqc-)WH>7gJM*~@vxd>cs;y?NxpVmwdmhUD z0vaFZq)ZQEM}4Cc#ch$sTx<2tJD7vYtu+?)Y%Xpg-H+Wbl3siGP_*V`t`B?h4)zWJ zcixsgd#QgrYu2XcR#YQ#&VsaK)u^rfZO%iibyvDOCp-bZ>cgxjyv2j1b$`Dlulhl) z_M?Zz)35j96S-|p6Y0XTen`C9rkU{X7M_=QF1o`%ccU>At+ri=UCVOUWTp@M8Lvjn zimLdQs_+dTKf4_M@!v!FXFWbV1V6sGWyhXItKEsNVJ!)3@EgE8l4Y%GdPOz*Y2r#c zgT2FP%y3r>dG8p#V~_Gh)^M9&Ui=yDL`ggJKk)Q_D{+xeUpHo?ywSC*i66~cr@ziO zO6A@*a=u8AFFr!Pw8}d|zGBfYFEK*C(Zm%?BbS#A@->W*?^xopN62Rf`5H&aH-H@MzT^n`+K5XZAzw1c*EB-DvBYtn!-#x{2l<*u$afrZ@gwAm2Kib>$ag$((Ie!G zkZ*cLccG4UBBYVtMA|}~=`(ja$d1k47j!LZo#aHYGukJ?yrpMnwC3pGiwE~-SO{qc|yVzj+u_4j1pke%);)sPf(eXlp~^-#Yh&jMYpa?Yj{sk=TXo(aeeNT|R-H8O z>-eyv_74wBFW9_X5FXG8Vq4$FOu=hz#+Un*vC0{ZV6#;cUs94 zrVnk5Y=&$_XgAbOYpvgAZ02U#CAHByZ_vu=K3C2`;9>na;}6_##2PgDCef$qL*b7k zpkJDGUwePdyg2zg^1=CBInFENQCgdIUccx6PSSM*d4A4!++x29Z_0KSaefZ>w$kpF z9r+q*OY6M+J$4+{y1$Vp!GFK?;Q0U1-ZYOPo_g(*|9=tI7)xa3d8bvUtj^lPuM6NL zNm~y$&bP|be5OYO)=?b)i#JzqisGlFp*wg9M&i_RErZ`MK-mc!+NAw+kF@TGefr+G zOeb&F0J+n6+H#z!!Q19N^)Kvop&i#b7a8hwrp-Qsy6+h0mhGIdmGk`kHP`r^Lu;<- zZ+mO5CnKL}{Je;Tj(`_?-WUUYY>#|D|D3Q39IZ>!nhyDe-09eVLDV{hGZsxO{W{v8 zdHVm>6#rY$TlI$ZTo#?cb`mRBy&jwbkZf!JslRUiW z^Yq7{Q3CiL>|FVDi}VUdfPY>9-+~s`9-)kPQHJWEy3nTWQyrwQsz)1gGZ9{db>RR0 z7S=ZN|Miq{Q^YD?KOt(}D!;fh{d4HkQx$ErZZ@Qi{+rBytYu-{R5^B}G*gZu&D5hv zqjI{GZlto{vGCElZSVgy_(JcKNk1ItQ;wpnX-AQ!`zX?!dK76?uhW!nSiK}GqP6&? z|KM3dXBBA8uWYx@c{nEXv^&Or+C47)v^y&ESWWlXFz(=tC9cVEc0=W9)(LaB59xHj z&iM4>u7&;c)^HKuZq~W4sIX=b8LHQ%%g~*AUCLlX>UC*qoi4H8)00{CYdu{;-lb26 z=@R@AZ}9QGJDgSL+qth{RD?BeR?)<)tfx!T%NA@(3->TYD%b;Pfc`k2j982d5(ane zpJ=mtS*wDt$Nj*9tM#`njFGMYo_x_ip)2oY4@9g^w-N!Kj34x?FY3YOE?xRzo?by? zZ{NY-*hBjc?tE!v{q5a}Zc!)k=lkeZfalOY(Yt^lJ8@-HR7&&!oVybSsB8}iii zLUyd47mstESUoR3RmY1vf;xUWMp$)@WbLf0eBftl_#{Z$ppP*1Q~?{|;Ld+L_~j z;g6S~XCvy=!k5vh4eXm%yM>=o`yprbkJKi9>8V5Q)kWx341YkjV5KMDW#=QrY5&a} z$^w?BzZz3iyY*4h{BK)zBm9^2vjt=JPeuo`g`lE=|%QJWT$j=7;JDN1wo1iuz!CAAqBXqNQ%4w$mA64DB zYi_`7XT9fk?xI}h`NB(13e}E1?GjXe@6JfjVA|f zh{k8Vvl6MZ+Vif!H`bYo%BObs6w-8C@=^`#9xkkFxBh z&W3+C1A1Teaqeye2{7Lu|wmT!i z(f=Jv7xpTb9mbV3M zf%x=M;zB)XMo(tceMk7t)P2YK?&e$hR`DKgJ5Gm>p^fm`9rR3TWk=pZdgUp>^SJJO_OFmwlr&yO=>G}J%Iz%B3-n4X+oOIU4fs3-5^JJg{*!qS!SO#FDE(bD1i!hVh+eF5j?)M+_!{n+fo+OrA7sXb#4m)Ae_^dMb! z-c0}0lk1!>*XZRK_Tde+Ewm+G+ma3Xr*8?{7Gzm-ojTV5pSGqprXiGVU}>B$Y|HlS zIHX5ULC>IUuWgb}2!`@&oK|_{t8@i0)E54Gn4kYV9m)HBPo34Sw(5SyN9*a?pfd#O z=($XF4(Q2$o(;kt9?>@_*3p#BHT~G3!)Uq6qe-qt|FvIrk?hp_2Fsz5Y<#KC#(#x+ zOP6;Ax-30@L)v&YaHw4Z*73wiUe$&LGJkBuD#s3M>am=r(mY5@8oe=&0A z$r$+5`&_RH^z;H*@y2bK+lA+zo$8qxmJQya|8*d+ z|F1bh*(XtUz5VyrxU=_9GIQ~Nk^NU2@xS)p_rLxe^zEd-@{{!bDSfJthgS!2>v@N5 z!6$;a;r+7h%2(HZyu|nY_uY4&+KqO6ssdS!Qy-($jO&;!3sZWSaI30g$pB?yA ztV_Gq8@sgesj#6MUyNAH1CUnZeDdF>A-5WXlun)++OsE6E_0p5Fn=Z#B(x7rBdt8rNQTIk^D ztLt=+|GhC&?4md3k1fAmzL)6W`$)saa4mm~eYlS_(!9WMAL&SG>V2dmrK$Ik4od@H zMjG=U?jw0)Z52Oly^quu_(=6*arHjZVPyq%*Z=iC(vi}Pt@ERfl;*e*(i~~bKOBb( z{aN)7H0~9LU(&1V;kD+Xu*W^`4P=HjF`jQG`MHYl|EM0(HvuniK23d-kjA2)r$^wV z_Bqs}`f=wWJwk87`Ls}v9{K&qdQ|@5-=|0S9|7K4;DvK%o*scOHe+b+OnMZKXZw0| z_}rPNN8}0n8Y9WT|LW19v4@f9BU$Q z%=9<&EJm7b^cOmU(iI#ob4Wm!CI$d?!p3If^vVqev4wiZt<~NRv2>OybYzc^p0NvfvNr%}O?OPPAp8n|aCW&oHiIbN>LgO!xlCPRsY{&h(Cb zST=(6%(I_jRWwh@S)`TOC48LaNzN1c1-#SPsW+BWDf+ynO|mMC2dei^5gCp@_*leSA2Hhy38_<1z?W3YQu!rkLdmZnOq#Gw3MVfI(k>Fv`j)au5!RDEp!}3Op8Pr&S-MGi zL;01joBUrRuWXz6n?4N2#g4{71%rVA&ifk~#vt?C_W(nCEJM9lyDzzw%u-+Ko^zh{ z{I2E3LKf)*?fV-22*LK!26Ylnw*l`4;Y8h^iEee`dHFQRG;NLA1k0XX`~rC0cZB>G zk$;8qQy20L0ZTRo9`y-Y0_t^cB;QW`{ zeRw!rw%P44B-@|FwrJhmkc{Woc|0GWZzleW=f{QoLJq~RHsm8_FZb-$&w{Yd^B%2m zWd-ZVkb}xx#x2XvhZP5Z1#1EA3pzr(aRKv}v>U*VNNyPS)V)tC>rcNuB=2gYE+M~c zpYn5N(XEnmK1A|8#>&6J z{D?VM+9xB~*EyuV9lqF^4Q+h8sXjD*3T;Is|Ky(ej4P^7t#8S0I*|1@NrqYXGu#%a zUU|lOwu0YhC|CGMue65E3sVp6&51ETAv(TBxM3so-yi;R@GQoVZjGgvn-{2$+FZp) zIm@$6@fLhYXU##cuFN-8Hn{48w5TnoFK=1U8yagqnYl}Rt{(FR;FIRo7;A}cB`jQw z@(ZWn{VU#D8xi5$_5q~{=*YP5VRUTNf4M{BvRdOAj_-cp2aH|idfm&s{C<7@4ZLGk zvG^c;b(Qy3{$tF{D@S`JW7tjM`}qJ5&6O*i@X>p@V5Q5o5Acpd*MB8G%ySE2ojZPw z6SH(48UA)HQs>Wl>o&8#Kikf@N*i*LL|)YP>;8-g_A6H5e>+<&QO|l==%P(l-`s-# z@@Y2!SNSYx-KKV&vz#O&?N;yD4qr+zH^d`_lCi=hJ?V zy8(3X(j7s1$!?@BO@TBO(j?K>b_<&d&()TCekk%US(F^!jC|dA1Q=bw_>y3NcRTsp zjPQStbCV}`hx>_=y8&<({r;!quD*Q><@fKAyOH4hJ#se^oWDozMuIb3?nX)@xzl)< zcraY<)CSAn^zJ$fm1!S6HMNN3UBDO_*kCSbRG+3@>r;+gE-6>9I0U42WwFmCZ6JnNxKpHM(&c{~ZfFc3GPpgu{AJ)?xK{t@q!1JQ%E} zIg56&`17DG(Oz3DzX#(tgavm(@XqiaY8$M1+yis!-h^kTIjfa6tC6tU5uL&J`v0I^ zX6@C#ac;iutL|Wr1&5UE*ZxJFW2Q4ebdKFGh#M$#{Rr(%=VMXpCv@sEylE@{Cj4>$ z-v*ZUPip_&4+8k@#HEPSIceV^E`CQ$o$jGBTGX_u3>$l6v*&_G_fe*J(mZWE8oSZ+ z=I#EM4vQ6JV&SwB6PN_+R>MNZKC+M%-tCvg5>YzyZOZdu6LgUqAb6V1WQ zlOC?!lo_4SV-~;i2K34{W$qT!*@GcoSAv&#C%Wpaz(Ro6PDVdN+`K!q3bf$`?PIy# zwTe6$&P>+*G1f)QY3qGKO@0D%Fhl1iNAriDmwY_`S)3Ezhz(D&|F~h|Wk$LqKPWnZ z`E2%Lu(w5U9qCgCkInPP@#PvD8~5vsZ&=){HB_GeLb)1y!Pmh@p&zRADcK(j{0M7B zn;VHojy)ep=Oy1QnPCrl{dvinNB^+mbGK6`|GZ@F-#vynwLRhs%xRv=w|{2x+u^;{ zJc;iaJUTPk^PQ+`dyaJu_*OCQ#KP}wj%RP$rTxDtTX&ypZmoq;C)nts8fF{xq--ZX*s@YLnZ+ zp@T6?!NAwWOt7!G!X97zRQMj@d;-R{*o#Vj#mjG2yzDOff5t^@>H4XAqu5r->(8H8 z-C2tP><;8rXSY~c>YMlLy8*uIo_Md$xtpo;Td8wjQ0JRGJi92^^n@M98a@EDu;oeI&x{ctq2zlvdP2)@Y58kjgqq&>$ruuuP_5XVQ z*O|>$QM4}C`uScgxHphC6`E+d02tt@{S@dFNGItKltsuLst-hB(QfclUD%I#b5$ zXfv?sx)Xx7T29x4exS}&byyS zT$1k&#@$qplzj_2y;}XkX5E9MyDP9GwRZ1a!G`LN>zsq-K`z(19|-UgpHxTb<#EJm zd_{dKo%f(I$_}f?eT|oA`7Y__r)WE*XI~+$+HUo4;kW`p#VGev|e^^H6Ry<32Tp6sK1NBjMCPPb%0^h#4l)j@S>;(zs}gtz#ZE^$tW z=tH^(z(@4Z7_D?pYwWc5f%ex+f35ITT4<^Cs;B4{O;`4aChBu}bRxC zUuhQ^|Dv7ZTl&a*btn7Whub>op!6?F-eSDOp7=Lctvqzgyvan0W#`=K15P93pwp>y z53(+sG8sQ1mNPZUU>q8*{w_47eirhV$Q7}{@GQ&T)a-Sf9q}g9$R6@&`no-_fnL)A zoJMG;eW9ZFv*c~&f6}X6t@}l+#M+Un#zeZo3H}i27WVW)x zr42~x-jjhGdl0fklQQ^@+$E+!I%g02?0hKW?#`vzf1U0#$G`Fk z_k<5V;hkyMXu8eYwmji}NO!Pg9(5z;QP-+G8kFI~(Y|uQh!7vu|9SuaR+UHD!b|6a z%4fP1y$XG%o1ul;-OGrRjaA!wJ#p6{FE8%rJl+GezdWk1r^e#%rNMvf2@{_f3*KWnU)3A;6Q7<(Cv{FAX$@&zy^pUx<(_ct zQ|{ZQv$x!y=$)4n1%4~KgI>gxZ?p38Ulczz$G%v-kAK~h?g`Z=-M5W?($(2;9$b7D zoq1!~e!e1S59mxR_U8xr)>9t&9wpy|Cp}!eb3(oH4&gb6J;y$tYXdyj`glGX;Hh&? zfSd60d2`?%o@wRdKaI)c(oeuk<%5@xJ^`NalRP@3wjr!vfaf!nuzuw8>Zg2vji=5j z^5}^NCAyTA&!cA@p09(R!qefr{Qys$@8YeG$@=*glTUJ|^B;UZP#$?aKFsD^0r1or zt2!e|?RP|cxBRxZnKF&=0DL(*)WU!%-Y|aNm2*-SmOb^K>xdvYsWi%0jiYA)jP-Az~aeev>de(<+f%{uFMZ@K#u z^IPYwU7Yyz{Xgj$f5PMDU7r0F-j?jL@83P;;d98}`w`zM+N|*ZA9(-!bk_Kp&c*id z6uvg+tE7PiUUBd`kGS)wL(=YXv;4<-7|fORxHE~LNqige7W8c=zJvI{6U;L_BkYtGj)skS?B~4De1`SHpYm zbSK^>J{iQPh))Ia>W8F)_%!k9Af7Q*_I&zq+K6up;#-Mt3*y^}Zx7e#ys^)+vP?{)9QNTFi0=LjEQiRjP@(~zg1Zugnf-}}gJwdH%;mRB3I-DU=~tpYEa zD>`3oUtW!tEz^*Vo85h!1D8vfOMv^cj^))mNg@Z0JSuA`(ui@+#9>TM*DZkP*K(_{Xl%||lf8deb4JF{^ zIj^jIor%ErStZUD&NrAU@EyuZC=mOoMds8 zu}deqvEph^t_Qxb(LIwgq8S_bD^0Sn+{xzAtxU}90{$T98CkT!iCn)~1pH(f?I|>x z#S5mGU7{8D;VypP6w^^Yk#j#L7u%+h`V2#(|&=?tC^2DW^%g0gc+JgLL!7O=>4snlnEk z89*lCLnl0ttXhR0=Q-dT;Op$ssNHX_0=`v_QO`z`2mW&beCa|S_-#3O0PR&q6h7Pr z{HVRsoU!qd-K{y!q=pC4LeZH64`tjxC}i>L7zr=!C7VIOknE_rf2S_?M0T(1NUSWIixNJfSW3@V>>^IR;6FSjgmH=00;w=H*!VjUdrR$v9vZ@UmsdLrK7F!ruPZz5>MqsQEc$%encUZ9b^)UWUfp%a zDW;Kl@$QyyV3P~0O(XU!TChzgWwZ>eHVxnvqukw;Z-Luo%1c=Z`iB|Pq`@PJ-P;Ww zO~vKT-dFj!w1P_$x^)HiRk&P%T@^0P@K5;E|XepEZ^?V%pfZn z#sCJmrx<+ZfWM2q-v@2(UfyNm)U|dmb)@c-?uI_nPh_Hao#?a1G?tOC!W8UIzh^f% z2MIia=mlO`dXT z2c7(yE^{e(xB-7^Uk4|6RNFkwO!_LY%Kh*M9wAFDcE5T48gvWc5q3Si_QY@i&3@%jvC(?M26M&E=F#X1D1!+V&rxRAMmfo zrvY3%oQUUqDzkVo=U{+SG>2Z;oZ(G*P2jT^zNIQFy>?jruq&ur`vCVOQDz6YH0D=3 zd*LHzGMQ!`E8pPBTVpwCbU(qK@4(ygO6T$|-R9CO%Fg9K=r-;`+CgOI?gdj!4SK~W z)8iR(EZR@L`xNu+*WgzUn}@u4`bB!lM3c=~(PoV&yB!0!LSM%Qh%mHoy72Lq2H>6OrIqRGP>!EJ|M2L8zA$Zn{d=Z^FF)Clid2WW#wPw?oV z`=DB|H&>lF!OR*!-jNa6d(IX!F1RF-OAi-lBwV7rRrW(um}enx19D{LIbYrG_v+bH zT44skDMnko7<|-@U-~J=Cc$YCoFe7*jx&Y2WB*$CF9kl40c_8NiRNzXkK|1FESM%= zR`+P&qv=6jgwIT5)58bZ5k3vPn@asAbJ<2$wxd--+JCCOX^GGVKH^hF*)Mo158Vtg05ntsEh1&=iTgu z1#UxWs^LC1>>Bf$(B!!Ucf^w~3BHZc<*FX;x*EVoz;9K)0}Y}f?fXCrZ9~i~iP-4& z8b`Kw33kzI2PC7=L2ZHRFMB8&WYHDLF>RQ^uA2mHQ28z&kMl?qNv{EiDW)?meDL?c zXK*ZZB7Fn6EdJ00ul=$H);fc$F*6F6c@{b1JM!y+6-uI8Z@#l7b3j09)_tQUA z`@Z{@lg*TyPB!Fs+LDhi=k`{c}2vY+!(n;IMV?kC>y$ZuQBciwpY=YBkI;rAOZKl$XgzUHq@ zojKve(_VUi_nXHYGxLHAKh%8bH=D2g$Z6kuba`L*2XDAz@R84+f7!Tu3v14Q^v-!p zzI(#p4Nr77eCp}GGg@CLl&?%5x8<%Al1pBF(%gTZGxe(v4b1pTs^iQz-S^Btz2*D2 zz3aChIBoHBD?YjO0}JoIrtO+-y~*fz*Z%R~!=?R8a(DgV&i{P)Kd!m@JL17U^xi_Z z?t4IOMW5LX54zyNZg|i%u*UN}roe-HOXJ-Zc+g7!Qanh)gF$$pK4m10uLTd%$mSsQ zx3c&K={{qSg*ND`zP9>4Rvz05{qxXWypTTXuGK5x#a{4;&<=kdJT$)HqC2wtE;`c; z9+S}<`N7?@!K2K)knYRK(#C+t9`I-dkEq>iE(Z_hS)4uKAwSmv2id_?Hf|z$Y$@fp z3n$8703M=&`U^A4>s-mFWKuRnGASD({5!EBvgb|6qkK2n`~mO~{N@sNJ%^8uj>N#F z1}<&rM-qHG$g4iwLU4*^mpe6Z(wJ8joMsGwgKR8#Mf3Ot;B^W32#1h1!bLudY^U%M zto_hMc5Od&k$wo5Y0zfY>&Clk&tlkC&Cv><(7wv9CX2nEZJkvHUiOe}jZnU9>vQ1b z*;ep?zfK!vTm?Q?UV)u0At%&9eu`}8eGAmrxXz1)Tx4UD1F3OZml@Ba?3S7^YYFuho3ETRQ*l}>!N4w|Q7Vs5JwK?+N z8U}ie+MWb$u-EqBV-GF@AKK#9625tka`N~Mz#oJ@QG7S`Ll#4yIlz^D8Pphan)-yc zCC3=Y&CmpS$%_V*a~bu|A&*ay0&lx;j zI(9sMCiS4s8tdo=Ml#DideCVPIC*!J*vrl3;B+PBG^MdQ;3OL)o4QvrB)gN2n5LZN zjeE<+W`P6Fj>f$;ZX4ButnE92zLgEl+9#L>@Hl1c1QQib_8RljTd_51{5QMHvoDDp z_SBAIi=mPFh_xwZPI{eNJAh40U+0yZ$s@CruQ5_I+_X~Wu6wADx!qlaoL=@0{NDRd zF}uM(f(?0&^6!C{&r!bonbRo0gS7JBqR5}hD((gk(nf52g|vLQ6{gF^7ody-lWF&h zjNdZ$x?~b#kfxV;_~m9Fa&w@YyHbky!_W&%OmjMJuB5Ch(d$Thz1LREfnSTEqwpSt ze)mEvcQ3pz7R^ixJ`K`;7k}K-jKw?ocF}|}2aB<1dy-*|4P&E4=)ss>0$LU1&rCFn zW41YO03X}*L%$Wqxs3L$Kp80;nOp&FTB%R7S%6JjfRCi}+vQtoJaW$!)Cn5M$K11c zikW(;?`O^;zv!W{Kl!|+e;&^`sdP(zmu$c64feOBbP1#V#TvU*-zb(@g^fVJ!0QT? zLw~XQ5!xNfc+SI#K3<-_Vum(>agWbKr*7a};*T+V`7PwdLT>hgpYEdG3vQkt2Ywbf zb=-pOEvz)@0m`@3M_gs%mSuLy?p0_zE!!-jyjWgmS{IG%srrPwkYCX-LisT(YScfJ zomKx(ww5tqCj(6NDN_~bLis85DN*V78UsXXIP*qIsm+g**F$={dX!1%q<7^%jQ4PlmYvxH&gzfup&gWNb7sGh zyh*R8_R)8RX3}Z-FdE0}`qX&(q~Ke`ufg7ETux(9ZIs&z&hcWG(fE_bqcr}MpiicD zQF%2cm0gY|J?(DQ z5BeAT&4U3xks|jYfsf`!s^HU3ey{BYpG&|;eo0k*vT~oJv25XEfluoIKJXiSe6E_^ z>G3+m=PGQAhYvEM`f=xvNfH)5T}Qwtd#g{MXmNsfkCAYSfs@9e#AEKDG7BH0pD?iA zsci>m@Q^)8@lFi1n0Tet$gZgGm#Wa8$F^w9Vn*c@ z2W^m9(9xi{XTu_ujV zCwZE|C0g{ypXARl2IE}z(XuxNwVQbd^&vHnaSt{}b<V!ktEmTh@h^7a zTP*w@d1lBg?+Vr9CgRN@UyTr z!tKR}#=8yW)%;KX0ptoeiQF1bXQkg}C3rAa+R6WR4u29JBy-3u<>arR-A10H=GeVZyDQNE$t{25=wenT_) z5M7kpYF1Gvd`W2DS}Ho~d$pFCi>Gd~VH(HwY#4Z`d<*>4Hl@Hvb5R;65DpqA@aCbi ztG)772Yh^^`6$^011=gfQJsai0Vmc6dpO0jtBehP+l3qLhxi^XOhBHzc@?wkGRA(G ze~L5atGU72TfqbREP`*{!m}{dETWBLAE2bC3_N#GXg(WgucjF)Mh*q_>oe= z^M&@{i%@4r?U?)``7mBv4sMz&kbkt4dS|UQ)dtq>YHjjj>KCJ|i!%6fe8;mrW)b0w zvRZ@EV=g4D^(C6a&J(^6nb8>A#f0>(bdIIgIAN!jc#flw#NFnvocb4 zR-VDVCo^MJdsdHQ$N7Fuk8?0(vB#(fzOw#l`uaVBt$jcdXxz>^r1yb$oOSKGzbtOC z);{~K!C(CT;J%YNSLOiqDX=EX%Fe64n*3U4&OLPdEt@qz8T8_?^;tJzr-!f4Vyzo% zmXg-eVe7N}_!RMnug~)1)5IUXKFg19BmVI9S$=#w@rSR^^5Z**KYV>w-5nzEPwTV7 zb%lE#I=KILzdL+Ame%B2g?ZKUsCzQc`ZMaU{TfmD%DJE8&e1*y%j);;Lt~Au)=Q9o_Fw^{MMS6jx-7Aeoi)CE$S>EV5+UunqRFG zE*3B29F2?cvDy1jEKf)ZCb0huzDf8X{~^no;iTQ?9wYeVO=izCI^#6!)$b-(@UH;2 zaLeZ3P?Zj3)5Yom!3gk4rTuj0*pJrULt4R3O83cg4tFw~lipI3{ZTo;AfN7wmJXEb zbl_&7Kn6 z;w!{yZRA6Qwa#!e-_q9y`PMo~tHRnkzN2|`tg@c(^=`6KbZ2<{m|uGn{87C-j#6G{ zgO|>J7%s2uUtm3&p*Qh$r|evZ>{J5Uh)m+|B`_J z?9FD+{Y~y-zFCL6@4`Sgv|crbZL^7=OWY0cdKPi#5qBbSGl{#NxGv&!XW((fz1%w0 z`t^=Wkd;9m$x6nOoheHOxLdH|WUOxuYCo4AtxNUx1hB8+80c}^H?_|8cK46$*RwL^ zT4g-v9ua5R#GS*P6;a1%jlR~MYE7y3Z~@yn2EB|}<=XBbf0vE?1^Jf`%WpyJNCw*5 z+`j`Xt?A6ZZj`rTxxjI*7X61S}mNDq6)^|SY`~z{!m(zbY&buqxyJKo&*pGJ%djLmQD(DpVQ}6Pz`5lxIR4%juN{N-mgTQ&N3Oj6W)}5LQ%0Qg0=`K8 z`nBzy)1sFA1EooPlRY}rAGxcc%bx7-q8#y4b&~v^O@7$}$zt)9c@v8iO_6rLhrC)d z?3Jao*ui+3wd*`->KIGk;3$6!;XnRbXTZ^pQRZi&cbEuxmQu@&bm_J+6O8oX;cw{P z$YM3lTJ^9z(eoAH7Ot;95nNKgj#+bfF60rO(aiPu50sy0%qvq&AlS{)N41yI>lSQT-$Acd^npx*5@s`YVmj%9IWb zPct=0Lwiv5_IXPGMUxzBp$ql-HYNAgh zsAECApzT=Cf8s@q_%yz*#kzRy(e(bemNP_Fh?dwkkyhI&SLI8_xeIxabF&=!KVJK- zeWv$)-Or2P^3!ij|2g}F86#$|qWHUw@P{%7cUzeiZV2;A%2Im~(tWR^{Kngtwvhki zr-c7iga3XC9lJ8#zV=!t|7%b5Udokj-2uI%TiS=ei?|&0?&7&E(5+?cXP2L%wpuc) z^W7)b(Y;gQ%8eTHs;WL+wEge_nUOBAX9C)3uVK`bYY+X1HN+XljkCn_Y&MTO->5w9 zd@7)UWxc*kJ8?%jTD}81enV$KOWsc%RH6`nJDJp4-T?`M1d6llb-QO_?j3irz`rbRPtF zHM{qU2JA!G#-8Lpa7$s|q_@`-zxm7f?R?KH;Y*QT|7lJ!?e`0&>%VliJSmoWy-5_A z&st#U>oN8R-83IEgYZnw>WkPv-lcu7x~utz;H7tk_YCsKGH<}g;*1_-Y&mwDHC$EQ zb@L(qPtb?@HTs%DmXtO+&(ubNzskcn^kcVcAJLvt>YfIF<-3%8%&%3IK25(&X)|~XZ<+k7aZji9N{2b zqU`C+P}fuH@(bh(Q-{SG+kl4}a~egR**DAC%I8+OKR|ZUoq~>sJWf+) znteOs?J96+g9Z^`do}|Zk!_Wo5M6Jkp2G1P=;M*ntP9fUo_m#t;x+$iGyM>BL3^x^ zlC|zQSFck)0Pf8H@O8?|uRUL+ zTY_G3*9jstpL?2+4V~GUTUY(;0>NGB+2AO&OiZlv(6+i0Fe-{#e# zd>6C$HQ6%FF?*N!ua!CNtRc=Q4qQnSXYGVN6!-R8f^_WV!Y2sx&Z{+$jx{4rawzWY zHNlDx$OPhaEhw&Jx{;EQlte2m7=c%P7~LV8>@GUUYV61 z?KD;(nkkR|n?|~1cD~zKobN`=e7B)6AG%#wOO)pi(Jfw5+(lkpW28GoySMxGCC?$+ zy%T?{o^J1`9ZoYJ&LNrwFzRTgb96nL!Bf#pw7LsAEf$^F|0z2zI)#0jv!Th2{9jKO z@zs+x>Ss@4ocWc^>r^E-(JJd6tK}_(Y3C#M7B`yN;@T5PBYCZ)i1X9L%oev?BhIp_ z@yZt3>n&~rX)WR#tu5NiKd8Qd?vfAr(+)04^dW2?>hUO}3-)x%;TM)+KYBPGW&98O z^uNXw=McxRP9cujIviE!V(=Z}xq29$p8?Nn z>gX$3!^SwzC9R?Ug8Ch8@(nWFWo@2xi`JN0^as$qQjTQ_M}Dw&%(BWO$JvVCzIIGn zalDhfiPYp$35Y-=&T;#@gMJ^)#24Q%Ug7?d5b=2-lAKQx9Az84spVwHC_^O zA{ZUD2yfwZsBXZeZePwk?)dfNKd*kod-XdhsNYFJ{Z0z%M|~*c@2%s5)G_h@SjUm- z*8oh_@!zPAXcY-)D|(5Jjo>W0if*E(=qC9Q-9%5p6g@>V(Ni=NJw-FoQhXFG#YdIn z@iCASkC)JFb3jXvpL~mlk`eJRN%@i!!IPW_o@gj|k`uv`oOrN!doXwlMpzg5+=A6a zT~()M+pm*XU%pjW)k$?!om5BFNp)16R7cfGbyS^HN7bol9qZNUA@H{eXEV{N@`+w) zzJ2*R*2^2`+n23l1KINP%7@T+<-@?3fqu2o4us>GQFJct=@{n+l1^vHY3w?g+3G6K zMAAQR|D5=pZnWjt+9xuxsOk|R{0L#yC7L?6_DjOTD?<3!goT%I{{vywD@*uKgoU5# z@n^!SpX%@z!s44nnGwoK5*L=EIt`UWc&Hr0{{dbqN975(uq@#gmL=T6vV>b$R)n&m zlqDR)vV>z;mT(Nq5{_Y=gj-mSa2qOz@K8B~Ri78YPvu1^EA~G?zZm7j|1aqG`~L^} z#VITC-%P(31NtQ>tAVn_*N|7@Ysf3{HRP4}8S+Z}40$DfhP)C#LtcrWp-ePTP9x=r zuS4Y!9x8|MAHhj-uJVLWSeEb!%Mw0eS;8kQOZbFkHBwfRvV>PymhcM85?(4pWeK05 zatIHVL--}|kxr>R;S-i6e8RG%%T1ymaba1)D=bTRg=Gn!uq@#dmL+_`ItiblatMdz zG*M23?`F#S3wRa5OXUfESeD?2W&OQ+rSh67D~%nK4@p13=^f9#LA-x=lC@7~hv9dO zmj4i`&>t}L2k$IAO2m$-Amji-UB>~ta9x&Up=_LH`43A zlJHrCml8gqwOo5O;Z1}Wsq8fOEk!oCuORM~!S_MLi+GnVOXFAdW5#Wy6^`Pqc+s9MR%fb>%0Yj4n55tTmxui{CqDwN zc|V>tOVz1-EAM>87lkHOv)??cIce542H(HpyTL9yFVaWU|9kni`Ts!h z?eg8o|0ei$_+Cc3k3V>De=)L-e&;%G9-Ohrs_620?p?EIb54rI+9U4Zw6eJ>o6Kx-lVa~;K-KLA_rACOM+Wl!&Ob@uge zIFIrF&Hz@0cYWEvW&Yrs#4(SsPvgOxkoj#q&r0@rlE3GzGt}0c`m1)GYnf#pfijz( zeREZFryC!lZ210N>h$9A8>JUD)kSGUfAK@%>*0~oDNNj$b^0#ms-I-6XZEOdRn1NO z(|gxdPa;o(H2R)HSm}=!9GmqC8RjpDSNg@!U9e|HG}qBLM6=bZCvoSVbBK;T#EEV{ z21oV1AEC_LDxber`WCkUtT=D+`~8HILHJ6-sUUngVQ>Bfe4b$4#mv!Rxtyzoemnqd z=3G2HW=&x2(e&Hhl2=}?)?oDx>bzdf$*d)AW@Me4o#2l_&YG@w#T{Ocw}JCqWLRZZ zDNl4bMl>t?v{}S|Eqp8fRf;e9bUuS{20mB=Wk>6qEbDrAF7mtRIOf@bc^-9q>MM*X zCfDt?%In;@$Xk<5+BEW-FFPOK$=K(DUeCTgL0CLn2+p18@5CSb^60I7AbtVyY2ZeI zIbL*QFEaC4`!Tr)3{KJ&Df zR()#DifcZL|Ll35?Ww(y{E~~afT4FQb(_}wtgW zW4U$<__RuXJQ+vck(UB`I>7xG*}?ta;1P^P*pDUfGqfq+ChuJ0E)3#aaI6r= zd7b+#^4?82!uw9%;^7^?0PkgijQ=W-@%BKLuK}Nv$uHSlCfO{o zhV1){r(W&1tG7N5T`BLb3B7I>7@JPt=<2-F`N)yxri$DHs4?M>^Pb6j8E?gxg8218 z{94{=&i~Xo>Y~B>!AWu`T;IukQ{V0X<*&ZmzwuYhGvPO^bGHH`{-_U2cNc2TPvr=n ze2v}-8{A@qIf5Q|eWQ3}?NgkUrZ1jZUe)=CoN-sXlr+pOI?^kR;hv0cNe;2c_Pq#0iZ&4mIC$nxWYq@Ggk6#znurcEb)A8}h zqcvum3%c9>jn&2A(S>e)9Xj6jN^FGnjvDK2M=uHDWmjXRvhx7{HzAKj=r0;KWf*e? zSBttT&7Ln4Z#WyM3@tMK)m_jfnfc5vtAbuKH^4W?h<+xKv_F$bWj>RLrwM0n8+)L% zE_#6fMp>Uv`Z9EzJIEM*JhPVk+g*$EV29i8HgJ%Sa9)kIVbpmOwrnSDwRjbUSG$mJ z_8BtH==)gBw5Rt@*y{OF@iw)PhC*Tuv?ak+I4&Aw9kP+83W&eeJ5}zI*N0o;!Zp z1qUAeDdnPzN-Munz9H)<_g#a$2-dgBUplMtxlQDkA2~e#m&q^MJ_2o-5879cJNIk! z&mO<7s=9uQ`YEimPhjT-pFV9>Wo{y$WzBhA{B3=+=in=Bnvk%He~4KFJo2M^i7WH8 z^KJ89%ljgpojlK?9D|B~F=oBQJN;DDDiPkva}iGm=^x}hm-m_LYcq5BBeQtAc-nX@ zo&zrchi5C#gFI!PwLI7GEaJ)W%;M?RH|ZAx%Obp*x9(8g!Fwt3FYw+5?)UO;X!8CXQY!} z-6#DSrdLWkI?yZWYrOQv>Za1+dbQ~YdL{XnPCdx~ar-vUJ`bQ*o<0S-B|VXDNGHyr z9O}Y+TiLmabpV@?(GAGs($V8Rz3N6TLY=|B;IpAq$d>YE$h!epw?TujotZ|QV2Nh` zI7~it&c5vKD_Q%gJ&n@0MYQ3Pt4Ax6U*Fc=`1nDFW*7!zpkaXYQ2$;>3OWN#8d~^55@&;@kWLWy&_kcngOJZ?zSBc`u_5y>)f?;{)JA zTXiaT8eD>ob^`ZO-qUzr#(N!nUmM6lnKqmAM$-4sh(6&~H zsQt~=Zs%LDuK=cSP}!14?kO0jvV_Cuen~%&G(Umf^=Ysn<06ci$7Yrt!H&`nMP~GP z;TYi<=V~ba2jp8in){8wcOCX%8L)~0ZtANpBF$I8M|izE!0TOqIXG@paa~om5k7C1Lez75~Y)a7kh2CeMjlgs0cR7s>D?z}ElbvHXzT zx@(H@W${S#5zN#!e5Eb$m@(|ut!uq-jIn3-XE_>Ycok(xp9Np#2o`?pKI@F}?l|mG z1bWGDy(TfZJLE!+=yHS10zE6haZ`BqF=VOH3)%?EA# z8s?PKv|Z8PZ2VW2Anx1xwy5*=OGI zxO*Mt8sKgQ?snb}@%}#V3U9U5TVJL6-RRXXQq(;Fe%%H#Kg2Ka>&BjD>b82QZmmOg z+eY2CxdqCQkDXd|h*r(eN_3KM8MAH~j9cq>4WxmY_F*=2pJY9~M9+G9y$hIM2Ij@D z_VJ4w!Rs5;dNs=e25@4)59uA|7v53E)y^mXXUTsHIIZV>8}GHe%e?z}-}SEnoy&sz z^}%VI;b-Ynhj?2W&fET>`ir+`KJd8fKUZD;ZlH=Xa z4bU#Uba0>WUDiI{m9L)wj%4tv7tn2N!!q(6Uze{;zE6?wTJmM5|J)lJ2>V@S;zHY1 zqn{)jw7pAq_T1_XV*-7&(Z|dMrW4s_-PAbQU-4!fV<@t>3Qr>}d#i9aVbA^%K9z7M zcW*2HRfOBo{V=_3t->>i55s2=4&fgg#LLFMhq`SjF|I)RUhZzokKW1J7skv8E4{)F zVcAxN?;%`oi)BOaWXv;cTP6{XX3Djt*els!+1AU5Q-0y}O3Ie)mTmqJ{X+Ghbl0HL zoj^LlYvW90m9>bnl;=+9cR%#heP4Y>1M)8FMR)%a7d?%35Wczr`JVww0edy)kr`q(L^*j zk^jTC?bozPVVkx~xR6$Dm)dOMr}p(r#D{I&c<33SkEb?H>(i7r?4y3`w?2(4!I<$k zDMvWBfTv)+2{`kiasKS_?u0rSU)D0-HD97^#ziWB;;yBEvJ>+9mnxgQ(|CtGc^~1B zC(8(jJoy*GAx}O|_+!Em{FR?^ShtTj$*{h!B^>gmr!L$}_%{J>77%XRG~Qk6Y;f&T zf3>;7II&reeR^mxjgQ@=yC$qw<_=ojq}_`BY;_q2XZ`k1U5ydTcd#=5hq7}4jHb82oQBau!txZ3>qlK#ZrqDb%CgWsLM-HscaxYs0eEk6s?aSdcM|HeTb&LF5H_<%DE8>Y<-Ts1q4LX2* z+QI$T>#&aLNVfk%^k0zp6Ponz5aK6f;|CJ2aoG}A<8A|Wm+rqFSL3t;JS2J89#=Yg zJ6!4LhOu#|j@}BKhuXLb32SQO(i){1VeNn~paJI=-EuvA@67sJWo5#BSvsCgJEb?9 zn>(g^Ad_=zpPaqm>&FgW^SsHr`U}D|pXclkT3hK1C$N+8aZtGGlp=joywt7z^Q3EP z?+`BmJB8y(K=aDez%#(xz*a!~;4t1a&U#{}d4#YZ0P({=)@Nkf``P%e#4G&-+PRE0 z-vRr8?*WC6&9=W8?Z2Hc;n9A=)713={KB~rocc|UIH0hm_2s+0!d%;RXhtdz8hi_F z9wNWm5Xqk7(Rt`o2s0thgY#Q3CX~7V5n)e9>p36xiED`eD=>i{Db1b#(cJ*qRV?VI zGhq?pwbs*KkkaYS2lIlXyA9Y+9PR0`cG~$%;e+yYPA}%3mCDu2>N7p{bjRtb3wumY zjV@i9?sz!+8zJWKx_JF(=+Pe!ou2*#NQCN~L};DU{;=t(=R+^LdQx;GYoZIVlT&W* zVYTVAsM~SG>sxw>$3#>82>W)*%v5K>6{a{J;eR0fUB+Q9EpI2MM4zJyGwHf9miiLb zld#s=uusC&>(`m^UlX3gcRlO16Zy{J>H*&4v+;X~dmCIG`5r{L@+A2#1b2JFBH%pg zkh--Yd`y$NslG=Lb`AGxlz#$ko&-dIDqtFL9iV>6Bb|>l@_*pVoZa%!-}+Wxd+5j< z?MH`}raK=Nb?c-usyJIBny3uXBf_`n(H7Y(T1?_wcz)F~;~w9_>{9>9j-v41oomy_ z=4HzYzVOLn%j~>@!nJp$b7K$mqr5*xQzu>@O}+a?H1+A5(bT%h^mm;4Vk@x{^qD;) z#hb+3fxekF+&pZiGgH3cg5)0mcg_lb%Gu-JkNspA{x96${u*%o+*EJUx9&a{*_+vy zDF9cTIkh+ELCul0fw*SG9qyl*Qg~m&UlnaAOXtm75ceEyD(JK{z5Rx{sbNdzraXaL zb{q~~Z#eFJ7~(e!f^%5+&~MCXd;EV-?lIevANUQnkPDm@(U%+_XUSKY5{L2KzRwkN zQ?2{XO|7>7?hHD2ZfZ^KdguA$*E>3&UKpO4+8(N*js0DGd;BB8_4nkf;A+PH?xDEO zKW#2{s5zmiXBZqOHt% z*|wHjW>?Ptoan&(taLhuwEO%QKKXTl**Rpb$5g>9>boWXJU3Nh*e~kHvdjkuSfgpEv2yaJTkCm+7=jHxRh&K%=t5<9ClMj8s z(f3Wlr}{UK*Y_u`rGI+rO8?r1RjuGL@R>O8z2eX1Q5)YPPlnfd-+}Lk`F7LBunBvY zrek>~c{_QA5*`J|6)Gc`>F*)<8-p*^tIR61wqZgx?;NFJ?@9gq5%)6+;=DV6Jd;l5 zGfUD7h|l6 zA+)XvHa1j6*EaNI4}ra*?Nf3nN9g6$%2(#-d@`%2lQZL!qcQ99}&wS*8pB(Lr6?W#X4m6C$I2YmH z=6C{&cc_1L|KNLjv2!+QbthpDarzc-h=2PD2W|Ke9D2*7dzAM8NvAhmisMW8O&@d} z+NL+#ifOZteD1qA&_nNI=uJbLJb9YG0vbmnokZXjX9b|P=$(cc{!IJ73g6*~23Pq- zgQ4|%u+^(?pQ4RJ*c+J{hF{2IC2raAt^aOkGvWHp*Eexjn6shllJsBkD{doh2jX7A zRhg@Z|Cq6@_aTd@cQJLkRCJ*&J>i$%bB{{?U~ozLWY(R&$aM75#)e1;JL{FRlF+<< zUx#;{eTDBh32^=kzvL5dB(etQJPF~;370-9eHgjssDHj9tbj1t$G*Vt%kq%!o%E)> zUN(9z@~(v)f1+KTzS(ypEI$x`qL47@05*Nun|=xqw*VY{$)|Js?j0}c-j_JZgZFb-sA49weg;JhAac?9rKkqPX)_QBu z-`?HZcPiZeWS#@R%9#M|gxBJ`DPMFKo`B>S?}tD?Z;-l2-Meg=^u#|Cn4by}H~0*A zF*rY622=sME7%t(27-XzoZ`Gdx_c~h_pZn+Nyqhjvf$L+ttI%Ym>)`-&L7BCjmHYf zWz8+T5u>?+caPM0KK;@`QLQ@x*UAdshjTosa;LyFXpHN^Ve;p^Pykm=C5wq`RfeA z|I_?6f;edH&R<20E5^}!#?glEjg6Z)SDo@&wMpZNCXFwO?iNk5ujI<}XHMh}R3bai zg%t8+8>D zK&`mHK-~Pabed+CS*>|nINvyl0?Zqc-g|?>H-ZzvNUw z3$0IX$4wNx#5|hOCnk}mFZGiyA{yO~{`t(%kKDYnZ*V5Dl_zp$N;J7T(%6ur$JOu} z_j_G>?CbQAvy#!v#Mh1)A)LCD85y1 zlX}7flB1&Z7wN7FuWhJdKJf87==tz^(to6DPygUYY`(1frUzyxFFC0;CE95mD z{|WP=TXv$;dPjDws#xYX3{)TSR~vi2?(j57-_jer9>&^uWP^C3jIal>v9*Lo8V9{u zD-~z`ty{+H?~;>l5Ry{pri5mVK75SqXhAXoKjOABsN# z{qD~T%}S1fo}swt*LZ+-(<2$$eP`e0*7_+0@s8cjZO0|3*I|V&8$lXV+Vca24hw%_hxKsA}^giCA(i&j!+20m6HyJ!Gj*l{H81akpdBJ@II;s54SyyPD5It`Lx5CC_ zqsy~Nn+^XqYX>?km`Ud&?t1Fu37whByJCK7kN+L)Pv1C2^i4kel`tDzyIS5ynKg;# z4!yx+)eXq}ZfRX(gC)BhYa|n;o#6~06w9U+@1L3%;B9^6OS1sHfR2d03Vmm!YpWU& zT#EhZy`=1U#fj;u7O}YVM>{EsV}x$id_4m>=raIX?S-R~GFjz3#v64{ULs zK8g2(ux(9cowd8}Z6`pT@3~_sGPALv5V_SnwjinB36j3k*JjO1{66&9+BR`VYq;x? z_nNO6TlL<$AxW!5dpi8aA9?@P*tmM$OL6Bqv$kOYJS5)UUANVV_Ts%|@JLs%0`pQu z@T=abP??u3s7`%gnY-F)KBn)IoHMQIJT`eM^!IcsP1XS8d-TU%-9J@fuWjf}omz5+ zTlXfOp+Br-ZR#0+ZK}{(wBrWw^&y{S)$9=6+8IBSlkVs0HO%R1 zo8D)=iaO}MB<9X;vQc&!!tcUWwNLu`@qRh^WOuka!f#$iXQz@U-;!pn@BVJPpL*1S zQ}!LnDlchUsV?}X@2JejvSq4n_Yl{Cw8AI7Rq68x^HUGyk(}B||EO`z zH+|>YjqW1ewSy!wW9%E^o0k71@oKl){1UPt*SGBs>RZvkeIJ9fLfDaF=$!CtyC^oC z@RIa#r$d`;nbKLrL(;>Wf#d2kW~O@kv3G^pa|9-?F!A;tF^$~Xz(rTa2-16~d)RjE-KhuXA}@nqAk`~c&gye7&zllG}?(`eHq%AZ8}l5?KKojYWERXt>H_gq<% z4BGMfS-fexm$Hh$TO41Ko+;aX2zynKehkK)RR!2qPJEX=4$0>ClIuvj!fZ(9(Qb`r z<;(q^=HA|09oYvpN3IOq&HTF|DLSq2Z%h7k!aI!L5zb%8FP?Y@eu&X#pUVpy-1lzu zTTi*R=|q>dc)Cg{|t;km!6AvsJ@wg#{Nz^%|mPy?h@Vh z1m1T0QR6TXc-iTEGwtWi3Z=KOaZiH}#5bMQ&&W_;JloII-NU*-I$HsCS2*iU`gvP& zE^Sm_uT0Fe;NuqiuoLg&41KPz=N{76bIF_Q>rj)v*4ni+OOplA*xztwqu`@Ex`)ZxOPs-Y{}-{_E=XY7t}3D zR|LLpc=jaZbgOyEXRup(JJlpj&wE&>R)5UdK6if1$>|ZWXsbywBohy z_}jOTH#wu6C0@qwM~5@=yLUpr<&crx8zdWo*c8lr&ZAj*FcMeedyL!v`L2CEAAXXo zmJF7S<7YX2v@54&&lcZGPRq_GIo;4iP9F`frgHKj$vZPYt#UZ{}FtLM?fG^ch$@3VTv-F0~z{E9~w&5dW{I}@gN z$i?fLr-~?7JaXLW>~%nM$#%*0g~VOWnnQAZ1!0ow%5y1gl1v|sE14ceeoChIVk~?{ zeI?6pqm1t8gtF5efnRTb<^1n0_n5{T*~7JXRS>|oW+nkK;J3eJFkSSsjr=)yR{PHr z=?6divHRf<={)`aajvVs6$BP)UFx*+%Z`w-Eo=VtMly4mA+k=`_zV= z+E1hn((Av->X*`!^!*Coe)d)O2i|qWw{ga(bV%8xi};o;s|4GDiE*|no*7#c$s_v6 z<}@Dvp?hD2(ac)!!ZT*4tnTG0FYT#dy!pWw3Fd5_BUC@j3PxM+W;|Z))4i}m)T_H%vEQhap{efZUw=_&ELuM`I$W*`r$F`G6(g;0QEy-gD*HU*;Z!@ zm>;COiPwIhtf$y>KZ5XFn9Bdw9^n+Q-|0=zchP~VY0<_8?ai;WXF9JEU%+}~8hyCJ zyymbE*?uANWcD(Ti86*pG0u4-%;i^jqD2edCLPFLO~jx>@or)SzR~_t(4t?Hi*|VH zqABST#iU7?dmYPOwBsJHomBd$;rD~sSJInGUbAS2)*kQO%h_tmnGLw-FhbyAEyf(E z`G+a+?-ih%8FYmefz3(r7rzJK>iq+F^JxHUiz9;G)DgV*bOi4^4LC(}=P>8_ zWItz3T|Z}au%DCY*-!S3)ml?pfqp67dD0x>uI1ok;jRrt(TnO>ONE@=+Q2DSV))1JVVq~@v>yiu&P2WpS->Mpg~VudJ&cBsFkcN)W9OlW#?kNr;4L!Z45 z?PY^uebnBq7j(K4`3Ba+(yqk=JXN7qwsr4%7 zsM_mZw&a>2-TvTa-uT$&Jiz+Y0>2ewzcW4y`f+vx-Y!66($E7TPNo(@gHxI_W$mgTRQKs%KcgpU)&P=ektGb4ei`;8Q7u}AnfO|)* zU%)LJobJZR28S-t;;Xv5oOp!!JUJuf;|${ro8KeHuJ{D|zc(OfEaP`9KW`jS{`2kn zBWH&@pV5E52zoJg3*zd>y7U|6+OSwJZAuidH$XUYJ@p6T_BtOq-(qW9)q9(>uN7~^ zm`m$@yhGNT_rY8{uinR^zo^@h&FkPH@_GYN$II`Rda{2z2jzns+PS9 zwdMJOP-g##{;#p4_>rIXTCQ@i28TCS*q^bcX>9l{_&+C1zo{bnT@`F>=n^UuJvlSb z*r2)2@6z%D-l$&NFdDk;`DB}80{We;>QuarHyy#v9SE1-tNCr3I`t!WEW2da#?SX2 z;%FRlU%tI3gudKv8#V*z${UUf&*0Gbo5#HferpH)y5BnNn6zV^`bKY}`K{FRul9$Q zjSbJY3p)9Ab5fOz*_POpa_z4Qfy)mK_{|NM2JMEr?Up^G#;$hMe(iC#44`k*evL1U zC2ug^ioR>F{!zbq>7T95GBVVJrQfT*CiNy^apwOSp<3`yPwg)r>Eh3osXp6JnI7U? znjpVaX3(y2`_WB@y~XBxfA8V+_i*-|*aP8v4Sgv)`(AiK;k*s*hCPs#wU&*pg51-% z(b+8BF?P>j#gLmpY{JncY0O*gHAh$z^`_Z;=J65QN7(LTzL4!r^N-rBx!4n#gYA5F zvPQOjWUkhRvejt+uM2saCz#K`tMQ__cTfBW=OpQ8$aVFBsu1wD( zY=y#P2MTe91iJ1v?>pZSuQ9!}NxFwgr?9UHyFh-*&kyT&i)Cbgz5e1Yv-{Mnf~O8pigPdRuZv{CI}LpteRqM6=^70ryT^(|`!>K2SGNuLYN zBBEJWWC3~h*>AY(N91C?fu_E&7(sPKo#yN|ONuB`;R zi~gc}L9`aT7whAw`ruRg;3DS(^670`_pAryBQp-_15Z$U#o2zy(%(b5;z9L?bSClG zL(m9X)vs#OH|jgrJ{h4;3(@73FU&dqY#Tf#UjL=ej3Bp#hu>pZ?b0B|?+DY6EfVC5 zo|R(Ux^{8az+ou1NOjKZHHyZ}CJ9*QqxeiE-P zSGef&I_1fRk;5fk=3LG4obHq3t6t(O$}gf`Y6o?7YXu z6-PPJ*L)Foe645B+^X|m=!omskJ_p}F9>UVnfB5tr8_MbF7Rv46o0+u(&IwpQfR$s zg)X~E>6Cs6ak43>KehMdV{TGD=KbwDBc$_cvuyO;fb6z+IbWN*(C_9tEB$l%zMF6C z66PkpZ_?Ov*KT@~7aJ-(%zHqzP3vyeM|1M*Y~8xkPVH|#pl|wJYn02$W5^?WtT#qK z;TNwz&%4rf)$9SwfAUAJok8_&V`pqQ@ZW<2>AynyqS8jU2=aSrl;ySu`c4nBo(s`# z>L19KKO4T;OZ`O;t%bW~!)wG({tVq7Bg{<`(OQPFl1+1soA<5*d5_74S2oFe9bv-# z4fI-1xY~a?uJjy3TW=?RmeSA;g{^|7UdotEST*n@-`_ynRoT3wan)by8_{qYpzl@C zUVRznyAsgYmkejlPilWnHe{_so+KUT-Iuq6<~kG7k+j9675~WQ#QRb3d~M2I<8y!Z z2Yf?D*W7FLF6=pD#-bO_K&Kg5&u{f?H;e%%^l8u{~gY=lp|VlG2GoBRR60l)xYg%uk=&ZL;2ZPU9E7v(Mp(m7fAjD zHYd#im$8n1_(k5VV$ABitKL!fC6P#v()q{Sa?n}~=O(Ph~BZe+bcZ(1f#|D*XZ0Hs|CncUxpIz1iT6fah z4alK3t<#UF4Z)kxCA2oD52+*d*be{K-v&PE`*G65npvzHm|O6pE4cll?|tw?<{ZE! zt>7oe#vUMBBY3tZ0vorm-M9TBrBNQnrrJIqynVo<@tNym@r}l8FNKp<=?*6!@%0si zY3^2A%lIC|H^0S}`UbnVM{DaS=a!+xWvq#PIX$gUyq@wMy$zM&h3{QnXhz;VaEzg> zJ^uHSuV(9}wu~pPSyqSOTx$EgSiJtvi5;>Gb(-t+B9mtG%-A)CRCW^IIgHdTD>`%Z6I= zOAhP_-r{)c&?%Wq_t-JU)i8ZO!TkP&bZVtRM|6}PKG=Tkjr?9&RO4bB_RDQf_d50# zD04sO)J0E~_dWjZ*x03O2j~md>6?lrv*?Ee`4aYKY_zq>M6{0m$2w{r(1Y zn7a3zXX3-1efEXU9lvD`it~G|z{KOok6h5&UGq};jhq8Z#+_^9%%NfFUj3L;^*;9e z^zoe6)BV1PU$S#3^2ls5WvG-^VZgJjL?blkmnYomxg#B&N0ENP zmNw_s1|(+$saNQm2F)4TKljCIlUlF%f~<+?)8^!9iLBX^*vs1dd)HpPkp9W1ZtSBk zmmOF7`aHsvR&q*r7i9wzZ&}!$zcY*7`Qzzuty4of&D*|M=B*5GEdE3b6JPckYj0l+ zK8$PLbq9lWesHP+l72f?`NLl4*r6e4;pm@I6J{9`XTOhV-}P`&`@92#1Po+U?Jb=d*}^1AWWb@%8W- z`r|10t>%8MN0Zq9#rHQ+&jNT-efWd=k2(ej*YEiz{2w~#435Sm`&93`Nqw5W(x1$5AFj%d8<{e|O; zH6B^lu49g|SVO)z34RDC=XI`0Mo+F~KYnbow&%FyeZQ|wdWx+iXAYC?&{^_(*7lb? ztYkdtH%(;UdSIT%P~weYT*=%sIddR8)g@=J4@6rucN8+_eDopm44D9*@qNq>nY&zh z23d^XaBo7q#kgyKW_JHV`B&0k`PS5W?XTpq$M23+=OiBP3zJ7V%RrgbCNA1%#Y#usXXeUIqO~aGD+vu;GUVCW3+#4;*441FC$!Ys&rz> zT7eJPPufU(VEA`aBe&&Pw+FD_ean6V_AmCm7l%bD6V`x7clYlh2JZVbDk=p4xKwP?EL zzxCe^u8*9S%u8+_ z(pkj4L^_+k_=+@=H97w95?4gn7UG-x`DU3)M-^1-3}n`xJ5<;i}(&i5L=E#`OGjrP<2rzk_eG4l?t>QTU2LG!ujyua1b z4c{Uwu@!IH>&o+?PU|c^c9C9bo-(!0wa|FI4c~-l3wy}o2ig5{{GffWo=te-Sovwc zmweUW5q+7=cP(y$vz)jbZz0q9eTNKhb!>vCC4MWwULm|Hd|$HnXvNm?_S}G^X!H^| zd(iiiS6bW6%hF>F;Ts9Nk~&(67wcR4`z6|J)At# zDW@;4XreslW%1n6gdR=D+6UkNJl0;3pZaSq(^y;fQ{!^+)M>&I%8a!>S$vWgngh2` zhQ`{N)Z@3riC?O47txNDoDqC|2r~f+f!48u&Womw;y&z!_i|n>3a>Esw8vL~Embn( zB6Q3bz~?g$u(!(IT{yF6_I!Aw6D^;e)>`yx?p$b2IR`y{Pm((sfvt}8`QzTK=FTX3 zGiTk(;1@r(^%A~y&Q|-rmz-3cdYCs#rQ44t>?Y12AJ3X<@EZ0g{0ovH!bT+7%MX9( z1V|%USIGMZ2HqLy*Iac!@^`qqZ=^j(Lmv(5QJadkUF_=Ng`E5Lq9f`zSza0-UWQ)% zrYDDgIX^Z1OwQcY%}=$xd48&I9r}G#I@1bxF3Q=#c^|VUfo*2A;|o284WK5i^O!25 z1bKDg>9wgz)Mr2Kl>JNRb3EKXlf3X!Mt9-{LGNnl_B!vPs^1hR*?lH&CFv|QvfH5@ zD;WpqG$ZSSgvFT~RmKtF@u@MC;j^)GL`chc7#)F!=^x?0ig7T3^x}Wr$J&d1cSu5K ztTT5FJ;-t!fAn{Y)10fI{p7_at2te3$P&uvO_=I^ICFK9bILj|znF6~qi`h$dXq*n zN_Vz;;rDRvOlK%eU=dJ@eo~XZ@Qkxl>TAs*EL7WzPj~+wKIMCw^gvwU=&Stw7Vqdm zS-}Kzi;+E<-$G2>v|j7m-SN%N1EhbI-)K=8wf@>44s}_zZ7{BUbLey!u%QF_l+qp9GscbnL1Za(LT;N zC3pL`I{m?k%y9B3a|HfhQ4f{ZjBkTqb&yQV)Zy9mJ*3fmsJtejId6NiXBLO%`vLeR z`wLhfMI-E9Z5l#+W(jZM3V1@Y$i+=!dhD(#40wkh{Zb zlc$}Bu0`J6;cZS=^7C`tyRenG<*4i<2vdD8J5b+M=?G!&-57p5Q8bfm)f!rBOSMDm zA@OBpXl+AxzO|myI*a${^&5S-q`@y8au~L)AqmdIK<~1U_+nMM8Ti=?#a6o^sdc4( zw_fMJjyhL&@MW(--tx9<3F*Ur+F@t<_e#R#A5GWx(#v9koS7>>db2|n|3Q*44&cKY$5S?5I>dpjf9wXfR38m)bsC}S_e7=b=p zIJf>g>MR-I(hWJWmwCn=%k+cB^6OeBGL8rO8LP2adObD`PkiAH@2!K9>{B>n!*f%* zV=dmVpe#eZ#h26ZpH01TJSjduiEq*PMffCB-&N_?NT+jT2A-78KN~)84!?`fy~Ac4 z#OIiucAeY=r`k7?FyVZ(3C^boYs%*(v^7K?rBn^$~q5T50@BCgjHO zVYE}ct1;=$L5$T2@Sn!#QN(>%>oISzXpdUh@0v$6hFWB7mf;obdq0&qOTl~AtU0xx z6thgSn02jX@!PGeYsuCkO5GIShIXrd9^Pfp{d(ii{5Em{iq^a=eq+L|!HX$qXtiZw@`b~J{)9=7B|JLg_ zIlT(EGvTWD0}OW6!9*JyEp!6eF)R~I%8sEn)isMd*dcaK0EhH;cg=3g{=z;U`(sC# zq5O`I**=7N4XIO_Vb};3?@)V#l&7{9n)nvg!;kIeO4?#kf7wd)9^et2!IIAI^~awu z{!&-Bht@m0H>sEEsj^K#JYZHIj=%1V_&V18FAujexPJ-H7Vzsg3M~^rPS7WQ&Q};S z*qENIWz1kJ+dnpRQ(HW(;w#lZo>s~GMK94Qm!|6444wSCw|+FgSBZ^M=lpJ^42ycX z;eKRE5SavC))m=tptu)4`S9QB5_Id5!>>AV&gbI)r7oXvP)&XIOXZF}q+Hpd3fD2$ zBby5A79`zsP_z|#uJ;7***1y**?~S)Uor$%zoWhnvG3!* zXGfmWhN_|0rS4gze5*okdzW6k_iyZK_qU4UqI)(E_*wI3@=)#e`kkfBnWTz(oo%8W z^lc_=*%<75W7;Oc$#@%9pGWz!7v*r}%Kr!L((g_xuSLB~xLW6B>5Jo&9)HqV))72s zv`W5(4NboRd>|e5AZ%v@8eT_b{u3Qr974xO$x{psi&;y`=A`~Mb(((`?J&v3ES_C+Z`GvG>2d(BCPk z@x)l#K3cfILt9*2!a*HU!sphHbd1&Qy|QH%CXp|csdVgt@m^}CE~=a5S9o>$@6cRl z42q}ycN#yzn#(X|B-cfQzmP|GBnxSiS2DvoHC`XGawsL8iKA?v&<8(kMKW z#+AjEY$?K{Jlgvz2|x!sBjddR_z~Hm`u|d$-k?tUt>jF4@x#yQBUfd{HgXkS&=}-y z6?imm;R(hb?}#GmhxPO|C+T+#PW&`;sJv*Ax? z!^=e1>|Ep4`M;EXug1lHDw}fEf6Pk<=1Socf6DEPob5}yHGVQ^Tvmp7(U5&fG2K1ZN`hFe% zmw@KfzAP3)fNb5OpJggtI(qG-lUwUIvnuNkrJ=&4ldx`a>F1>$qGQJ_9W_>DbMeHe zOL$Qlnbku3KcnN^{bm10`gx9~v!hY=jaa4~ z#gxUpPscSG! z+<6@t62Y(fjZql+D{!0EZzXuA5H<<^_)qm?bLOD>-AMXF>-RBXmjJ4h#eIw4DG#{a zvQ%&Cd8Oj1mtM%81hG=n)%ApU{SDZQ1eMk4a(-6Yd z4y7-_&$)#9vlT|!*Ja1Z^k6hO%S4lVOWtwz`ZhbN%c)KB_0Ia$hMw|sw#@`2GcxzM z-80htUihSdIul;+C7r_5zZ#b(C{H+vPQ<%v(Ca7GmhyAoZRfy?Ececd@rTe0&@qDX z``MqSy_yd=W7Ztq;OO}Jw%}MzKZsA6rwb(CKjZD$UEs2U@F-=u=NK5<-Izy2J8zge zQjUjwRMKk@VJKZ68 zO#DCW{OPG^K;xeEbm$gmCSyUg9#1}Z97Hm-Pm^bMlX1|DG`peMAkmC5kTC09nNm0^ zBcF5@R^!?mj62b6-PA_)!8UNI&MI>+{@mD~*^+%W;4Q*z#m6$~U*>ySw!W9=>Px+H zV^?(PldEqu!;{ad4EyIX+Y$P!%x{`pG9xuJI4^Yx z_v5q=s{7U}0vnUsi(0{Xr`$b8rdhSCUb65~+LAdhwb8xDm>-DOhl1D&p@(~}Cx}f9 z8_3JNVY`>JB6=H5ZvuG(ckNK$%dVBr9Y#OtbS~{l-n^CFb#wyz_mJ9D4EwL%VbZw? zWPQEtAAci__6l^jQF|~t@0JL>=5)Rn{^f3?@L2rzi0<{sKH8n@Sf1#h)HKS^%`x7{ zT|3%@u?a#8Z*+Q6Z#)%~R&>aZVm}ItA9SvQeM06W+4S^gK^x@7p3pn!$Rq1lgkH9o zn_Cod{w9Ha%wylRV}@Ph-f_*{cWeWF@@(wv{>BE~$Lo@%-Ee4k1aa);>i)d@9*At$ z-D9q8(7m5-V{ee%(uANFICO?Xw5)`d89V1C&YZxEr1lP;W}cJnQMTib*v&-)*`;;P z4@IR#P4>S0Y-FNq!$uD1T#4?>OW#pC=IqtAoWszb`FiRn8;Ed3i>AADRzBU6@4a~G zt*l?%JMuM)#>ToYUOJ=s!m+VA!1#LyEy|A#TEsgkx9J=|>*~~%b!!_=W&OfBV^ePv zPF-)$OGW(q8w%@|q_4xaa>EhxQl3uplHQ*4l9t8ZgP-3E^VeXy3Ay)MWIL7Ka0~4) zarTRY@GAY|4{;xqdu{0LJ0(XaGNuC5aVC8#+5R=>HqOtC!TRsSr_j%mdm4L*rQH2( zb$2>x^4&AjKd`SqL3iZh;H5mB2bcX=WlIOsSz8}v29Y(QbC-F#N8dVG@C4@$D4X%_ z-p}0I^X~Kq@Px{e4R{53Wna=*R~>`dac>ftz4ecXKTv1NR-HR%>%57&3U6+Yy(f8_ z;(C+3s*B1hsIE;4=RWI>^ohALBAGH?BAxK4ZIY!Ov+){BFA$fb#{|}}qQ@HeF~Q#R3{w1C0{FG^{{d$;pxbKfZTxEMC!5ctB>nf}Vdc8ctFJ~l_DS5oJ^p>vY?%Sy;MJ*B;U_0e8y zMtUarboNnsSMwew_W9-FW7(J`N3YDD*RYD%U!^UBvTe~krFN)2dLuwI&9y~(O(XG# zwnMahJ==~=*>DjvnWY%u?uve&g9(|&IH*Y8n zqK)p{O8bA}`%J#~hx1cj?yGQ~)_IHdO`>3f^os5GZ077+?F*kosn7Z0Xi9U`8tR}i zpt>J5OT5|Gpu2XG$*(Ie#@S@tmj26JyV^*L5kMGSH0LJk1feqYkir20Q zY^YXQjEU;y$dcWGcX-S29p{}2<}|+-nZ#W|{~OK#?1Jk9w1ay>7Wb$6uZO<~*KfeT z*gEd?N8T4ir>EM7Srh3#k)27G*hreLZ#b(?eS`95a_)ATQ)y#g7DvWeuioDhqyM4}7*$K%Q08Ht0;@rom=>>M)x*%zWG6^`DiT$v$e-aOWL62laB# zLTYWj!vA7YHoKYV5#NSq@MhKw=sqK5Y|a|n^~k@WPU6J%u1wch-p~F2rC-6<$#=Oc z_%3B#T0h7hm-@EjyRG0wSbbPM`uTQKN8b{cyW3X_e~Lb`52()6vBe$H`KfvK?Bwp~ zZH^V=en00}^3aWUCvSH|$7`VP&F?ky zz>_y8c>@c+Th;qbCpXTtcX#MJg6*O08s6*~!np4WpA^$(^{e{yHp29F>bH#<8-irr zPvOnZ{^(|Rp0e0a_0ykiu+>N(+B0gKQwd$B!5@d)vr=lmac}X4y0!Uw&u#_xkaZ5-@}C7QE~vjUy!Pdng7J0AYp9pGQyd8>p7)i zJgQ$cF54Ewm*t!33CjfUlg&ZvDCy90RcDQlngDYudai6mvhVHY9ESXCrYzU}VbKCFej|a&`eXaJPF`W`E!VM`siE;c8#lN4UXl z6F7#n$B^e3J_h>$jkb!QUPHI`7mD{65?cxCYn8J(+sZ z5A`;_xn(c}zM)nx^;^rtc2^gYhX`_>@su+r$duGw`-kD8b4(hQE&OxFFGUar!K{!1@g`Wwx%oX z$2osZ8<>;SFU|BjBhW={vi;dMN$2)w;#+Z+qcZS#1NogwehCcAV}-B=H~eQh_P z6XOOQIzyjfq5H z7|SkdZP~JAm`L0i7-mm5#98L>f@EF@2%nX-qR849Hc4=tRhrP9r~(s2MxzJ&0=IrF zJB0Kz>88I$_UMg=?~q$MqZS$MF=c>cl5cm%^q|&x1#%Z2mRC@KJ*fa2y=6S+swor8 z>;e5lBL?(5^^{Xj>C>mIeB6|>^5St*CRbM3QzutWylirLnLTboX+^j0hkQeWf6re& z`Tr~bfs%WSi$uUTakAa%H2b`fLxvbLWop%dkFlkd6UU9Itg4te`LaHJ#+*CGtzgB} zaaH!@sgowzlc!YKSCvkhSO$)YDo&nEnL4R#@`+XUlt}qxyJ|wY-DBe9iT3!3lgjPi z*j*}HknWPu$-lGDE3dkGO2y@W)OX3b!~X4iP?aurIRL!j$|>zt4b@XrbbFCs|Km6 zX2_IrrIY%Vl~t5iRv!2cO;HmJi4MfzcSB3c$4F;D>mO2nRrw_RB@-(nlS;42eVWRu(yEE$>EoHSwzQ z{u8URyfJpllu1olV°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 z%0DrGmz*NZ9gV#DbJsriK%UdF_dxL(U)8e(*Vp%4x}(Udc+sjFYQMz2vFzr}c>xwB z=vO)xGSX2Z0cz0q7kQ8JE*R6YV~>oo%$-$Y&GQlabnH)5iV&A)f_=JJ-Ec}Jno@<( zX#cPstHt4akbNRQRgGH3CKm0vq2Wop`kgIE?f3KMrrya{(Z1P%j~lm~xSLJf4H}n2 zIMv!^M~~~#aQ-gK&QIqOODqQlhdogJ36gVUHLAy!(aBS)aEE+=aBg~nlq`2vN$z5! zn5*w}@8oK4i-fz#ALXF=n}fAi;!24d&AKM(*@~OjDT9XEA0t1*q6FSRld`|s>q)ue zpp-?_*qubw?nFvP%EGT@-A5dx2%LX3*ZN5Fu;IE>rO+w-krPiuBZL(ju5$3lkY;Qx z7-}Cl)=pn{lA>8S)P8~V*K6pN6RXliRz_;RO8u58g<#K8TO{lvSzCzY*S)Pzg2kQ7r!e}hULH!UvzD{`3Z_sEfJ2w%flhaa1+oe5e7`Gbp5`OVk^?nDNX zjU6ENt;DX@5M|i+G}lfbM3*Up!&(OWc^e!Kko(R+CfyxKavO+A+l2N(EM5X-@TJyF zyRnratnu51HO=P;xf&{g@NguZX|VEIIMWjOk!|X5QNXQBo+f7tNns4}TJb@uJ1R0C zz9_ABG~DvwQF;NgQs}@lrQB*Lt%CX#Lp`K%+lkd&TLAw-eV2NW+OkMNY=&5NX*=R+ z(zcPbzWFBojWj?XAm+a8x7~c(#kZ+^lXg<0Wwe3sXs~5dTBGk#lafeoC8ZXV5>Jy7 zI(WU*5_Q{Fb zJ>7Rh6B?SY-R4=AO*KfWcf4tF5A$t=qm)Q%lcw$6Y1xl;--z!z<-o5Ti0|_5dH4zq zsawMb^|07br{8L78#qaD+h!}a?|(;}dFIO;!)cvzN~?s^n(ng+k;ukbr1tWZ4;)QW zj@s=rmS$RL6B>fewe5B(J}nxj-l}IF&rtY@^%JZhbNCwOtK1$ALxi*S>1*%Y^$C>bDF(EUDqXi5Llu zF_su}lw&y$YOWmx$JmdMPKb0GG#!yJH`o#0Bl=zjPjwoba=TDgmOz}s^l{)vsaC37>f3}(!GuvjBXm3@&*0Dmt zo!QnvgSNw0i?)ev6>$>d-8jpUr5E)iY)VK&A#Eqr-qTuxMKO(=R|6edRU2IW5^ql+J5@_RjDN#;r(67z!{$gr_#@V28 zl)GK))n|>N!WciUsPP%~YvDvi)&OEfUF0P0rYLuR(7hjHBHz5>e0o|4m$a5L`o3kCq=TdqkgqCp z(%FRihle*Tq!O}LTB$Td+A4ieuwJGN?>Agd z^NoPZKq`-KA!t>E`leyjK` zA~u^X``*NzxWIRW&h5BHhG*>h70;l(#QG(EZMfZ?LSWCYap!~+_QMHW@baV7)A;zq zgLla(h!;CeIeAEoo=?1l=#Ua-v0BTmroBHk>%RGcva9)a6`@9iZ{PJZo-$fLjvwbq zguYz=f1>|iOIe{u*{jn#;Ut-Zn$2a@(4&Dm^>zffhQn z@rcz7lJE~@Pwma!!BJ%y^(^&xW}i?g`-FXXv&S>)i6!? zB6l#Wi`+ewTD+kvVcn^8(5sEt@OB$-w;DRP;Jzt(GknWF&9Z(%SvOPu_wh?@%nJ!> zqQyVBMMn?RfPsoTfX{<$;H)V@D`vC{T{Y#C_0 z(4+(6w5Btakk^pTg*-pv{*-%2Bf;-p^7SKr$aCQ4T)x&FvntQ#`PbfYhVQY^s8aXe ztjw8=%+_ZJZQATz(D^REX6Ur=yPMzr{C{R{u%dvp3>JJ#l4bW z6Jc9kMbn?(KjL1@?|b}y#P9q3q%S|nZ#h31CuF>^{ya3$g4^aN{TvXwNXGtX6aA4@ zPsx4qKlZ-)(HSCPcF_}7>Fl){-|1y?tIH~1uD!C4HNMW4EzEzigW`_0m`LidMo%+4 z`XUb`K#qB=2f2|wk~1s$@)lnf@C94}Trpw{v7LU)o~7TJ<&}#$q<13yKhwsy)7mBN zZItu1q&!K+lF{2K&+U}6+fT>sc^P*Jy^?3Mb@V5Zf5A5MPvS1##0lvZLN7{Tc}m-I ztQUCugT}R3FZ=dvjP}zH7o>ixeK3}i{tt9<$8#o(p#I4@t<32~=#;RsOUfu9{kRoc zGIqFYasQrQM&}%T#^Xu&Qoo4S9eoA~#?O_DN8#dUghf}LUK`1m*)aB@zi4ID)A(rg z9MTu-;>c)hP#Yh?g*I=;!%-Ri9*!>8p7oH#%*)-wxvtJ;Sf4iLq?&n?74f~i;iixO zklu)n-v$potjNyu-q$ueP-0K@mCv}Z?SVi^SL$2kGv;<#H`M#Rdpc$mlNVEb_CqYXkM8>)SjN>^Cf5u;*@DPTDNcViTNvcZW$wH5&pZR809&l zC%9!=)cUU5MsoH{iAI{AsW~6CVSj2e?nF%uZdsvDKU!Dg17GoquGUz;(~hJku@MeQ zU&eqpyU)=YI#*B3nb#@tW7b4coS>=utusyPXA$}mQlG%HQ_gD9?>hRcoz1`xKd8sGHzZgsd7f zWNu;=p-)fBW1rJwJ)Kj@sySfAyRe7MX?jA&b#|@~-Ti)Bn6t(+l9AEp@~h$J4^MkN zGNwM67;V`%-5nWy6MmMxCL#aN=>NBuw&Q+wsrVG!eH${9ra%rUE)KZXaSP3}p)f*w z_ghH3Dx!^F{j0~`-gnJky`c}BZlqHUSqox`J5}RE_3I(N)~Mw$I|rp)p>nac?hVDO{>`LtU?Ca#U12=HPmdrFEig4^Bu_y-*b+u1csVVSmYJi%e91G zK$;?97>eIKmB&O4g$Ch1uYfY0YG~C!t43-4g_aNm87NcZR=A*}*O}78PJ&pn+TeS6 zv~dC{90VCB6V4kBk-OdajHR8IQ#Xh6+nf1Uq@9E829Y4D)S}(s9PP_@+wSg>NE(n6 zbU8lYyBcWpajo_vbaEyg0AeK^3g3|*K|_)g?zgTpDJr8^8xLEJ=J{O zQ;GEDDq@MQ<{Vf0lH)aPWQy7(zf1_(JLQDGLd*(WXb&ZQ;k;x4r97JG((Thklp zF&lKG2pt>A_oP9N+NQGBt+YHhg?3z-6gH?#a*LRbJQMy`5Asm*s|F3R zzedYwU{{nop#uBL7sFHe+N|>2X5^jWxcY7)C~ap=)JlG!~Re$k)p z0tr74s!77Rvcau{dw2iA{i4t24POn7nD)(FWFcS)+@<|T$Fltf=`5wa=AQ^38J*8~ zRiJqtOkRiJ%1xffPX2GlU)=Apmmk~A|NX~*&wtOc=lOT&+fz>Axh~7|ROLBrcn-mH zNO}IxUg5bS%X5%$Ki>bN{p^ew&A-rf|GIy~<;Qi;I(9|$At~i;IZ_tAl=0?a(Z=uW zzmqSFiX9=VZZs?1@RF|E*4-MFvG}I_x9}~%Nc=(~j>|{S%MX8no>!fGl$6_%UCR!8 zlVU|}3S@f2dR&>_u!foFt5LTdF31_8r9OWc{a?qGZ}%pk(`4u%nM_dASvv6nbmY#) zsM7f+F{)+EFe9kQQII;4D|h6yOe*P8>K%Dnms8t&vEd-;KQS)K_}SyE;FPV?pJ^S* z(r9BC`mF=PdBbBUwH5ft_&Ji^w$3l(=Q>5;X+;jxioUKVMw|8LX#Q6D-SKlpDH0XZ z_x28kX58=QJ_cVgWDpjX?t5K(uv0t!@}Q9 zjtEDR<-9$d7zJiu1)7a#@Mb5x%q4QF!&u(&FO`vy*FMCo`Z{A)& z19*L2qN$J*O-dVAPGt~`Zq6Y<8<5eUId7VtvbN;8W!yYM{DjlGo*jIjr1O0Zmd9=m ze_ty%hS-9OF^~CsY3&TYUZwNeq@-J> zk?t<%V!lW6y)E)DJ1(&g6Pbe55*aI47?bkF!em)aB<=y}nvo?x1}}^%=B%d7tOX7# zwx8mB>H71wXbIsKlBeC;23mC0v{k>AkdIC3`kE>4>nQK*6$>gxjMW$E?w+_#QXBQ=av$z;_48T+$D> zR=fEs?kF~87SuM{sA(2Qr3V&~<^oOg_4MDp)6O1f752fcJOzJ8aF$l`yN=&f#(=Rr z*W)kysJZN$3X!uMB>dmw{~W)&*SA#r##`ftlf!9wGH3UXm$MAvIl-#G0PZH`xu~Vp z^ryo*=d4P*`=_vuVEJk3`4&Cj)4^_V+{frodBSIKJB(%fz%Fe_`nC7x@c*ks9{;IC zfd97=`TW0=DB%CyL?QoUmJZ?HPK;t?pnt&)BZPT&<|pU@at@dr*^K`-eV6mIc75NZ z?|l8q}| z{u5mGzmr*U_mA(!ZRsk#fBc8IyA6vTz8^HuJpTQ*TO71Pr3RMTy1#gx9?<1yM*|{|H6~v z#Z0_;#0zP>i~1jbXB+)uJ$<2)->>;?=XnD^kxj_iLfYqv zZ*RLkt?n!0GXh$Y3V8bfB#`8v+OqH$h~V$EXWjO=ZnwZvXBoe`=a5(kg)_=`&8 z`KX%@PQeMgS>t)O{E0HFVC?xKWo7gH8c#tDnZ*-XR3)QG!6Ec3kq;C^z9-|oJCE;U zRbLSL*!dP;(3qgN%gX)s4v{l@Sbt7gN{Qj$o_GEpdU*lTu(m|LhkLk0SHhk1*Ob#% zn72Q4W*wJNWVs0?2=%%jf562;E~a-SgqCVx4cg6|YAD2@5K{^hj`wh5o>diq<9Ybx z+h6JJavo-0nZr8M9gFH%Ju`CZyY#au`p!y&ne?sh+qB#{%Vn?dC`i5^JGb^&&v>f* zP{a?4HND$XA3Kww*+*@-yXr1n-tY+cJ&da+T%5dFOEz9F)+--6|HVF`lP^*xPbXy6 zA>;NM>TfH)avK5Vl+O?S2hk7MjC-^0?$0F53c}=uhd_N5{;N!wmAKKSU1MCAo>l^4Vbz0k-D=I6JYm5J=68_b(8Tt*74HaNer3OKEdQ8s+D zJaRI{stcWpDVnSE>p5>AS9czpK`KEL->ds_%e)mRHgy*(2B9`asqGJ(pthAcn%pyE zyL-q@0k>W52$ZV4xm;5!t7j!mN}oSABsE0ZJUlJeS-n`l2kU+M{cLpq>S?R8hF-^W z5zl9NM*rOts^YnlvEUA#ck=rdzhCkDGC!G%WnPv3TRm7tYG0By7WN`mimzx5MeHWp za35<)w-iLniCSj1btN~c5z?9}l&3#L6Rgzy)~5Pq{0hmt$NoclgRTo+wEhog?*blG zbv1sUxg>L80z(KGAmB_AWCEcE1Vu%i5QGV!1VqJ3H7K=FX*(dc0cn{)q(Sj*R8+L6 zv85Ij+n9o43pHBWf~7U#(o&7>sI;Vtdbr4$WG0#KxAr*+Ain?SeZF~~GiP7cT6^t% z_I2&G*KT57@QQN(OZ%0YBOtQ_;)R4a@P)CD^-Kfu4jFO(8N*GAG6o;Qy#+WaMOxob z`6?S-r^|7L;-?yDjru2ZDVrYPCb+t;rXVN#^dan7M11BLG7(L`L7XC$^~J-~zd^LN zNni%lN-2l=xv9gGOKlV>VkS2Lk`JHsDwKgYqUP%B`wUh7bwe3B`pDP$PU={kwh2bh zy1=IYGik01xT7SQHcF}gyZV@1Y(@59a`S?RhmiJ+A_W&8$lOQG2mYH} z1h-4+rB0W`O}!;Cmy+1Q_t@?=OJXy&_{@^nLF{7@?gS%ieF90Y(1D7d<$oMlCGo3G*by2+o6 zGH$Q5PTS6fw3To2h)iGF%sS4;+gLqrjM4uOk<+@&_0Zq57x`K;izc+Vif-ag;=5Zs zMPd!#%m3=wYUr`@Ubd%ct;bd*>(`CQ)AnF}U)q}wf4wC`t)pMB@~QTpbOesZwSZXt z&hg}_Quhs}r0K0r7+*`;1Md@qT+X7}AK9EqYl=l{614IZt@EJuM`-N=W4GI+)tpON zC|Yi4y+(}FX^vHLJ0o)pLNu?m581P`9kd00PXF*TLfZzIY06BRy?)BhOn0xxltk`= zOXP@f`Cg|Z@Br!7fw_jKHl7h!1%(F6&|c)Fyh4;$nDUxOc|}{iJd256VWnV}mFV-F zSyl_Jbmo%|b(wU2K{_{(&Ro)%6Mv`t+%hS#a6;g?70yH8OakXJa3;pzvT)2imGtH* zVaYOeN~=YUw~N6GfHyq8?JS%@y*RrpoE_kZ?EQpsBRHAhI7!RSqfriWljSDn4Cefy zPirl17iUyu(K2d3)oiH@!X>KK3ka?ZV9c8?TZTlfqP0qslYcYB~ zdVh0=C4B5xvF{Tr8q!&MByEdl>9zFai&(3K&u?y;fi`hNOtd_jU1JU|V)x&i%ZzNj zi!j+;sA4yb8e&qUZfVErV&UMek^dS~x+X_X&$ZC-AmtUnnfiQDHSVz5VQyE~_3ii# zDvdq|(O|IB$Y>F*4|BGZ#cT;(NO~oA%M1lM`k>N;WY%&)>okj(s}(P~y}V355Ds1e zC+XDrXK-?<;zU={%K)X@uB4nIP0;kRu8^{cEMw(ZMQt~5=I->+gJE_iu@0HSa&7M% zl9Q+8Ym<_h%4}?dqE@G<<#kDUwsD43=GZd6`?v1nrYhYT;08-aVP4c0*Z9{8=SNkz zy@Y$T-T6;RIRC8t3&ob6^#8@7?CQ5p#O(Xnaeu0M4x+55qF&#-QLlH%;+q!Rd`~X6 zdH=CEcZu3#)?|Nj3v*&wgUcGdXKmhsJH_Lqt$zVOGCzKrN7n1IR{xMk*6VVnRo3hY z!k;4E2Yhs^<7wx{jAzD0?;+(TQa&CXOUjE$`IW``;t5NZE{TfupRMPUCqH?z7jDG* zfnV1#dgyG`0*9jUz`P}nxE)smt|@`s#g8=kz4I17#a?kFPs={EIFe`Pp=7IlW66jS zQEkLGqglS6N3*>Djs{6>0jWK=IKEhw7j*5=4J@(6WBdn}&kF~Zl)!^v@3gRg8vO`< z^A~%)w=I4S3LiirxTI3S`M1_u<^NPv%cnGbLxB7GVoKBZ58wtbnWsur=-vN+ptrqX zKvXNZj^|OH{n0+Y0gL;1uUq^u^je|Ue@Vp>DWOeP32BtjyHPu-+DUc8Vz=+mVz)PU z$xSNNv*F~M|L+_=OUnNLL&{J8A5;E?1^53h7ys4<3(l;O|F1HX@wPg{?1}8mOJ9lA z&~8i64%Fd|Y`(PNa=v4ef0i@>V{&&jE2 zB~4(gkX>xiXY?p3%oJP>HLE>St5-^6;QkY6Iym&N(bwlGiXMx;(3a&2=lwu zLQlpiksns_$l6`_n=c%>&qQ$7`TRSA5?Xrc^;`srXn%gDw!f+LsrRLfSZ;@$>g93W#*xf zJPeNn;jDm^PJi{ErFy>lGpV7#X6e68<{M7j zkMWjyz>U0RE+FH%jQcXCOP!b}ZpM6(F-RM%{*AexCw+$O?Md5|HdDtVCy2E`u-d`7 zWw}q-sUPncvG!#p$que9A0Di6>YsLmkUo!7r;SnKL{pD>IM73Zey?L{c~%uxNvgCW zXGmZ8a=@Y=`_{UTEH zKpL!NocanV<|@pw?8uTX(v}QX0)eO} z-k1MOPBWu%R^`;!B)$02I8zi${9em7*6&uXHx~%qc^$`SqgQE~mZXe#P`)YNyHz=7 zXj-AEEub~6+#gSEwX6RwJgqAUq#@!+tR9aTd zz}KnqsT$Wqq5q<<(U$(t5lw6+Y?l3afBp&M5_i#oChNg0B_c88b8*gbXxBZO=vq?nMFV=Ha$I2Det7YWO?!uB*xBjmYG z8|4&REc<@#*iJ7drPRp&Dy6>yeNye2A;V*D>?D%4<3?Z7Kk72&kL@nAx8l2<7oqeH z;Wt;2E%-x6eiFQn_tl-|9Ido-c<^fc zS9DecFX4S@XF526_k>P+@KWBxJH5dxcn=|bHSa-ufgkbCCj6Vc`w~8kx3}|HknJu# z6MpBbyz92}@ppHu3uf`|?3jYQOVdwv><;$heZ1o>mELC^eS;(Lf85a(yny$AI<(+I z-XC@#p>f5S6PenLqg$O=p!qvi_+2u}z98q~4vbtifAUfDO5(Z`ompj&-D9**)zS7FngxoCZwfJNtr#< zRzjs`YD}0t)0TwUGi^@9R4=qC(O3044GF*Mb=dP(z0QV&^fpHe%-&{if}Vjpsm|_g z)&MI#)2f8@7kdlL{^C_&cR0dl^g&Aq*-XfpeNYu)>#Z=e54ttc(+5>L+Kt;&W?Pz@ zFxyf^!fZ=3;a9$MB+;#E_mqU$R>SZjZFLfF`9c$USMnZDI^!L(b3{MLDrLM{rTmJ} z5^Hy|xOYAuQ1kgb{ATav$8Yvt*i@iQpF-Q4UXpLzY;VV6x4FYLKeOHNrFtx#Wa-V+ zBWXvppfD|`!a*y|(jV){(%;}FZ_^%1mi}^wXqA5%Y86mh&VYKVBi0LLS9BJ4*cgYi z^!tE(0!XoFk);jN&L?bj2NX%uR$;>4+;OS47A=J={RW_8jQppe-w+GkEm``VU&1Nv z#hDJy9pFT%v(@(So&GNx!kRDE)NU|0p}p^A^l3MK*pZ)_l zoz)!i%Pg00;RME$zNt5jKCBr|w_In-B*v69_rW;g!(kB+ zWwxC^ftKdChkI!KmT{mGoY%U|+Uf*n2jjc!#vbyv8?UNWsXZ+7@}50wnS=Wt^SGBY z|4#kV78r*68KDcWvQ`f87W@8c?*2y`YuA)Ak$ z)5dqZC0{))XfB*AwsI22eYfJu{X{?a#uxgz-JE^$^T-+^w#`gumX*#7E1hW;{W6RG zRo&7Pq>anT|BrZILVC|3vEX=gZ@(&EXFPF5d>zwO*zFEpNl3urIuGm${G)l#<~@>k z4R3#UOqHsyHwWvPQTkO59;bx+Fc+xxge^I;oW`!kr#YRRne-=8#*JN~|GiMc^t&rO~~^eY(v0lb3q- z@uWqN$3AKLQWw}O2;*Foa0E_t=a~QMrK=jnUcm}?Pfot8a?*g_*Ae4Rm6Lh&8b^%V z$;m|8`w`<7ZVX^o;;hzq#5hcgo}_q>F7Tk-Jm zk1O72`q5-LgWrDHnK?UR?7(6lbEq$czQQdsT7B8n_nN||KFtPyw#ieJ)HiZgp@3X& z`V!6)ic;N|Lf4(9bo}Ev;p5K)O-eJMG*_K^sFInKHM&cQPV)AY=y-2WiG~O>OEdt^ z&UV0^_HYR+9oq}5sDmd{PbZw3mgzhgQ#JjMsfG_EBuq$Hh3rf{p+aJW1XRe@)c>fE z=FGXswAwsj#R4z`obFa9n^|W>V3@GVOgQ{!epgp>Z>dw#@ruwlKMgwosY2; z3rhYPQ?|`=x^RNxSi?@nKvD@=Ji8UoGgBA9b8aus{xf)9n94eqVUt#SD_mzVlX80G z%~*iumh=r{&dAN7fv0oR6;tDxnk8&^_vFUZF55y|u(7X3ogl`{jcC#|SSOV>> zFne3SiXBGFuV0J3xS-{{{m$ajmQnjNi^DBf?spf@ZJD;;TfDSo{{A1vy=RnUA61f@ z67_N48KIgAeJXMPS+HLurPM!8EuV-@-`>$UCbBoiY#Yrn(n{~a^@sfF>|uzRmg=&j|ypaWgN8Y zFQ#lNv@q#uEZJGjxOW}>@bx^48f}4Mo)tWkcx3!DZ(ONd_S`a$z5gd#_=9C(zIq(n zD1qe*mYZSEEtjws!uYpZhO{knPgCr(>`?VzbfveeGef3CJOlq0RmZi1lRjvuzKXrr zu>N;yWDF?@v*f|w&F_q#9NioJ6mKBLp-8T0!B`caq zv^zzi(xMQtC`{?4FiBCEWKrm16xfyFA(eIUz_PHi+m++-t5mV*WTlElC-UjGaO9+L zy~0^Ss_p13nOfYV;J6JripeRKT(GesC$x6CO?tcBv?@Yvm5)T^oWXWZMQHjCsD%}^ zz%nhfoVK%>7Gs_$+{ma9j%(xfYk0MwF63L-VLZzN!P7 zhaF~K+E@|!RUR(rl)KqveL7d|?6Xc4dW<8K6D~KJ&Wu{P%=3LEN{6aMont&pKq}%hDH^&u}Idp!QM*w z`FomX6gBI&)s$A3)2H52Q^QEs&-T{xY`ve|v24n+LVM09j_z;X^Wc$l$l9+AyWP9Z4m7#KwV=gsABp0M|4ycpF#`eyZ>CJ*zv zg}7^$_t#h2_!8oVU%&0GYT>tk8Mz|N9F6$K@R2rVrH`|-uf@e;c%b;AeTS**O9#$Q z6#C6n$E#GOT}&C+|BO@T4&26< z+2NEg)0KEJzNg7vRNZQp$flUsIt-)RAth2wi5$-9DUl6@QX={AwmCsq z?vU!1oKI{Wq4HfwzIP#8IA+u&zDB-nMWb8avXpkM5BdvL$ZRa$$~p4A)bEWvTX@#VyT#l~ zSxVeZJhHZvQ~76)T7PC2=EBjrz()Uy zo1L_lKl9cyFFbf=+#l8cQ@6H@{inAgv|>i8El4)azPsVPx@a?d5#7d~@qvs)imSWiU$$HFRBSkG8kM>A#jJs5w&!n$8!^=)0Nu#kXfieCRC7Id?M z7JaJ2s=r!ig>TL@_u5;~d~Bgl(v4X9UB&}*9RFKvl~rCVt@8Q-Zz;?BD9hzmc~w(h z-?PeV1#(%lyrP55UC?f0Z1Ov2mDl`Cv%Kb#=3JHLRI9w+>7GLg-&pPr-%wsRIS1K< z%onaFOvaG8d}~TeH!J8e3p$n|Wj#&JC~^*#C>VCn6!i-g^?C(=i3MMws9%WeSmU;t z=B7Ys=)UHrQ2FdcK=o&XvA6T^vIi<>FR)>u#-g#SYL>mVEZd&_ ziLKPWd~GhRp|F2t>GD;}&9Jvr*b2g=Pr8a55}ZYskeg`XoGKs~Pv(ywTJ_ZAF@#k* z&AG;WCsKNKQd3UHbsMjA9W!Lt2hEQ9K!L_txQXgcmSShPs>^trF}TDj^@K8Vnyofu zo$D-A^N@cs%4HPEY%WpIlWO}#l4_u}blKX>KFks{r`SFLg1#$3Po*2FuD3o2FZ1g` zwhqJkPS$d54rc7Y902Bkg88_s5!!`C)1bYvm-aeE`wD2sisY1c9U7b$6v>)ugVjUU zL!n+#*wgjn4@#GHE4WJFMk=_d1y==Jm4e&WbsyZM;Y764kpowUa4*3<#e$s#EP5Vr z{%qGb;VMvcB`LZsu6E9l{7z`KEqk`e*SeEE=KLae>s!j=OLO^~)MedR-Btd9ZQ0Yr zquW_sMEq}5{PyzKRs20&mwuov`vvJlWmM8V$yNbeh z6onV!;bki+jpt+Erd*i&9(yik>TsCUWOsQGD(IKZv<8t@zm6$0 zhUH<1bWAyg5~>(kfMHg;iQ%mDWts8d+4{N(`DMSGQcn+ZHNqIo*R@P7ii@Zx2>v z^^&|3#b?zwDsjbI*g(kD5S7<*_KG*0@=)t#>1aLNrH zVpn;$PiXt$Ye!z4vgfgt5Yw9N7D7tntS)?JPrOyVCla#7I#sd>t+Y+(T&5Te8m)IR~hx$X^v^&B`ip>$Rm@#a>js0`VMsaV`eZOHog~V7i>P{jr z7MMQ3IDt8=PVQqL;&s-;%FXCty|;oRva-L#C=uN5P!Xw#Jld4Wt?1K}+YB_XOQ}hh zciQxWuWQOZ0rxvlT?f4AxM#GQFhzv_{&mw`fO{t}^MNsSPAU|2sSR@GB}1K2%Tr;p zv*kOTBDeEOigqY$w5X*zZ2IF+^8s(3b93VIgfd!9*rUX+A^xaWdWlj!#`v?5`h$*3 zYfMplkJIHQ?B6=nnE~>jN4hJ3vMZ|=QCw1vRl~5LrQZs*NXLpt-`b|1 z4_<&2+P=nVQ{VcV~-|{8BES-ud!i;gdYT=LY!9%aS>#w48More9g?iCUQ9 zUd)LKvyFP+W!wkmVV_{idH4zovm}&5niDNdcQ0njJb|n*Zvk_&PiB=iv16(~vb{p( z^*HWz+s%9*#l2=b-{0L++YaM0?MNNMWuvB;kbehqF_60mbyBwfplr8LQk*kVXU>~r zrTh27VI%Qoso2mOV7AQct`0a>QuL1Q+_K@UC9|~p_nP)05va}*8wk}|GL}7$4uI6( zpC&}JX8ss0Xvg=rL^~Ay*ZC=9o`ev;Oz+o{Q3=GX_$q!xH zG9q+s%LUxDG7?)oq0oqyqR?e6%nh%QIcLfzX{UUW_KL(bcyFI1;fGcDVHN&T;&Q@U zCjF4`y()aK3V$|nA>rF6tt5P_3g4>2A5F+EO+zt{3f-ten-aN%)=d(t4|OWMR)xQw z@DU!JBx8-(mRO|Xs#M$?R%r}Xr7^SEER9)KY4|A(>Gve(h17d2FT9}}H7TU6O72G4 z>(8*;lcOvjX!`m$H2sk`%veuoDdncq4~Pbz4ZBo##iiuCjDM$Jt-+*Gmu0K2 zAm$LXc7P%2iIpWyznk>RNpC$GJaWPc{V8BJWtt<*Wse;wt8faf!-8(&Lz)&VjRk@T8h4)C(i{|p6^z9J~~SB++{pV9@hKJJl}$QHyD!V zW@K8Le(ZO;@lKL=H>IIY>udUv-)Z{4e@9zjSJOqi_}3chE;aBW+;`G%)u}Xx&_;4) zza(^FOK^W?XjaR_{chwM>tc897fTGgW6jJleYghHH0vM4vT%*8nfigIzRO@Z30s^@ zRGe)2of+dJrqGJXQ!&q4F==@8Susu(^N1C5T)3x}pu4$`uW9Mh#pzijr-zVRY5EFs zv_Zl2-*489zjqhXDvMRC>@xbK#TOV;s7lQV7Y!Ev28BN#{CQ{LzozhYRgb%jPn7R) zv59{ejw&tuc?y3L__=4{KcO%dTKIofzIhh@F7N{uey+mL1OE`;-5%=U|N9DKsfGWN z@>N;*o4}9r%~bx8rfGU=C;2}M|3-x|(ZYXF`HC(4TJRez{0$1fZKqjklN6lW!ip+i zVzim-JHgWX$P7*9p0Z|@dLul{g~q?I*)1CGQn#fB^R@O<%iWo(Zf}7O5aa?f|lLchx}Z_L!FQsoU4ITuj~mPRq@z zX8$;L-+rmrZ&1U3qU!bj7?NRCuVp_^cA|ynN+kH29=6J@ff&*2lb9(g<{~TRQDVkh zF=F*y(=V`M)(~@;y?C=;n|3dl@ma8%f|WaZn@t$2Uf(TPl&_@J#+?c1P3~Y0bQa7_ zz%*Mh+ZD`FV5-l8nFh>83ue87c^8 zE)5bcJZILIVhgSiIKIB4r@q9ICYbfbooUvW^`x_#(9`wh^AzJ3A(HP#b*7}vsyzp& zJ(_+W7#oOpFUk}KUIBV39i01(kITT z`MuRA{uus?EshHn$N4*Cy(sHC(I4tL=PdH)dwF`+k76@G)`udKmh%9zhJ@?!tOL9< z2Dd9o)L|r1DdPpStz}%iDdnNJ+g)gm5f7n@AY$ool7k`oymLn23WM&w>V;I9-g$mJGUD|*L=j8R$^UNd-y2nR=JZsZ)Ks7 zTug{RVu)TUa(v0m$Gg6$zHfi6O^c1`@-K+uY zk^z;@HAy)y7S0i zk-5DWjLgu`R?bG?JC8oU3OK)-K~*U@^K70sE^-X9f5BQng^%q$TW7YxsvL0H@%r4T zr4&k_V%i-kcAKk~!dzwyZi!!-6ivA<<72qW0nU`~WHS!AC2j0nGdrf&lpSQ#&PzM( zyIr;K8WBGmJ z+8ZKw7CE-ap+z1o@}TDY8=-I`(lD`?%bg)=y}%i0wOY82Z*rabCJ$TR{vM^E&$}`dNy8%%Zzt_j_h~P*RpTDHm`2-wePZuAeLGJ#>12U$*d%YI1PId0+-^(ccCEn zij)s$mcs2He>);EVq@bdyS}E@J*xryZTPdjJt576?3EB-PskQRwo6D~p(!@Hq*vXd z<~K9(iN#dLT`PRO3XkE7!Sh=hJG?vl8)#;VJP5P{p;!G3L=si{=wlUdoO;5h0jf=;HQkPwBVq~KADrZe#_bez3( z{-^xF+?t)l28*@}9Fer^{!CMQ57D zPnkvMD(K9z=qyc7hmO0K&h+vZ&*5jJMW?``bG}7qD0Hs0=u}|F?{Jf+xWM{emzID3 z3_4A$>QaUyZGN|OxB1;+e}H$_U!k+>-6*;J#+F& z{j@+OPlE9%{3p)Y^0e^e?q(l{XERT1o9u7osFsp4>bt|LR<7&LS2euO%4Kc0=xwEp zN4wKUxWi)Gs>VuMVEn4Fn5jOfNxuI3;H>1O4K*f(OGn z+To_W$ES+%Fk@BBCA~3YRgCB`z1N}z|8}HEaTS6qnTKQ|_rSs%`C(>THB#w9xLZ!c zToB1uyR`#$%4yzk-g%1mJd5{>x(5*I2z|c)%Xt{6@-X0>JiN-D=bp~d@afeZNl4Lr~CjO5vc&ca;cSKQ@sPq~{u5_gF3L$7$;TE3%h zi1x~i4U_w}Y~#OAOXIQFEO*PxxHHthy=4n-PP3l+@jXMrGwOzvy@21(-a7mJPfxF(Y;XA~|F+h(%WZ3H!J1XkX>wn5X(iI_*uK@Lkbqk}qeAt!}m+v)N);K&qQ{YUPstVH@{=oQ|{g#&uh9(XCnm z`f&Lf>t>zm{@#ReMs3ErV(tFAQCh}>qc!-ycXW8xsTBWNb)(B>o$9)`IQ-Ds;<9V% zip!$cY=-B1`5!<|4PyR6%&b#MfgzrJesdJq>FY;@vmO{#b`8&}m}B+Ys?yt?wPKOx z%+x3{fXqLXFezvfNO1S3c@$vY1xIabgnws@a)j6qml|0nJH+gKUsEgFVn%k*? zJhX@hhfrG#YP+}0zPdN$c$$zoAKUWHu+?WktpZAFW@bxcVv2wENv*VjcSc-%<<4@S z_@dLKCvmi_THC*@rp6IpwRYUcHd{@N*b!nEhnk!5KvsCP7F+8MJGGxQX``Lk`PGU! zo6jDPmhab^o5bqS+NM2aHuzmdtB@ACDz>T)inI;$q+uaA?v?=emw#^jDs}bk;`)d2 zQhMx8>L^x$%od-0vUE$FrA5TJ)+1scDkNYR?0C5A8Oyt$iIv(~8`Pk!Wz)C#P7Ts+&P`1h4ZYc2Xn%V6%T3*5Z2Kiof1#xplsRgpWFD$pySAt-ST?wf@43KR zwrcgxcKt_E&D<01;aVOik2dr*)eoEfRk*iLdgHAAs^-DjoFc7R?TpvRd9iW*!!^_x z^Sjql#^H?OaP4Y)p|iI3!F_d}a-dPSdw~HO>eZY9q7)+XZMRyM7lQ4~1;czNUeiEkC<6ws3y0!w*#vagVJLcsyXlt1bjz2%)k1ctX9GvjiMW+SSjbB7H-Hh? zU8!x$j>M*YBjNm{f24o8x7v=)41c+|%3kTOss}1iV&XL(^*j8Zk`tW(H@&20aj&5Q?w#`OLhRO9Ptnm5^i!ilr|nse`i6O zyBIXWxuuE!D7x_;{g#wi4iGB?oL1-Ag@uhfvG5+~bYYRjqt8is^a-3A^l#I!B`wko zw2NBP#@*_So$UXax4blnEP_?+1|_4eSK*?$XSzlp6_fi;Y6<6m5c-rFvW!8Z-x*b5 z)yNUJPq;-%HL7BF%gVJ{on%pkoWkeFPO5 z8C3!FRqs!X)gHsPi{_HsqvY)6V~LCX?lL4k$S@vDjE7S3!0`OX5)%l;?`Iu9qHgZD z?-ZJK-H#>4X;-mFoHl+)s_l1ap<^xWcZG+y-zM%)T7~u{=vVA%5tm=zt=-StrqX@u zh@1$oU5->|?j7Ga)igf$Fz)8L3vqv;UEf*zg*q)WWo}|bSQ~ldw%~2+6D9tK%WCemt1j58uRrtzWn-rXMd$tzg@>F=xyJ{xb6c0x5a(BZNvCEB^#VC+JtZV^7k5tS zd};=I@`C$tnS`AzsF^G8qXWY8H6^QULk2-^xz+GtO1Tbh_ae2BehoT-eNETpzPG$S zF(Lf3vVBc+b3ayjW8%x&@0avM051YnyTlXd7jYq^(rLCf@AIrO(Y?5C-O| z(0}&>iA*e9V8eO<_Hv?HprUe7Lk09o9B{$D*EQu%vv z)5rZ*g_+WW*LzpTZlnjlQZX-`{;z!5!trlg)945|>#@mG&-f9w*EdFN^^81Gt^TTl zU$QpsciiUp=ujCBR&~9#oUOIV}TP0nih zE~_W$slF}iuG_z(R#=OGNgKyf(yHE1`FF~$%eT4HvAO9@>epSStr%&40 zoLW8g)<|ZR_BC1UM(@P-Xyv@AX`>;fZ78W+lNeW_1=dKf!2ekO_1pfKa5nrg;j4eG za{Q|26WK9|xkUT4solMX7BG-QWNQ)^(XJn-9o2=`P*=r$k#bKE3JbJA^foO}!qa#= z?}dc%j`D6?IHE!4oe^(t8uUrbhLz!O%2&}sr&>xh4>qyne^dwd6yW>Qrs0urVnk&D zIgdiMaX|o==xq$=y=K9%NM@z%yF9M?u_2TfJZXa|%g0q8CL9i$UN?6zFluERm7Et~ zrNj{z*YMQjz|QvLKR#`DO2$#KJ0;`hhTocFr;MZ98AD}UJ;ZZ>CrwxgnZ~XK9{2cL z*t;Oi2JSB2`n}wXx(wT4&-ZgzeV_&Q62>^hzE4IZcBg&i1JPA0y^ANWd^@_Ts(zYn z=Y~H>yp59csJXeDneb=Eh_trSuiG^H&iFPvaoNm$JS|$lULWAz80`hWnlJyn!@i*} z5SrL#X~_?24`a=SdGwQn+u|$rXt?jrH%`p@F+Djaf&C}rj3&85rO)?aeOzL?u~_wF zqb+#r$(VNBn1aknTH<& z6Y*u?bLKmU3*pPemx0|d(P?n$X{cl>JRd%jHz%$o+`h@Kg~z2=DwmF{trO`z?^#J& zS5!)+%_F7K<}ph}%I^PPxoq@!^hK&%*5i5vyBN|t*WrG$^Q+2e4WZI=o-U(X^>9Td zs~N4*rOHam&n&CvESDZpWt9cZt@!R&DQ(6@?g?wa^=YS+$a-9Nb`D1NO&vj#<_F3y zrxVvoW$hs0)~bJ~tR3jMVoD=IGtu*7M-q*_! zcX|T9RKX|CGdViR{a3UOmv9t=qjt4ZT48Y%fg@J5%=uQJHHU@|dd?rw&~gSc=^L3Lo~Pyagu6pukds;$u(NHkVeua9rT;7T{By9USlH~)oT0&N zYO`)uwl#V*n-6$3W$)u7qmA*7uf~mt9~pn^5_=!u;%?~@dmmfSDKqmkHs6LFa~ z|BG?Cxa*AFTwJ36JGn+QG{W$!QT}e`kt`3{ua^5dx1bX@_5*h7yv>pyrTssuCT*-F zMIS21Vjdh6fOXdd#2SOu{$VwGxsV=VsGVpN&~wc2s3p~{zLJQ z@=NNR`p1vvmX&&rO5N7_sj)Zx8tF9x+3dQM@;Ho3=KnHpDW#9=WlHz<7z6HNSeE}fIZ&FAf0u+>Cp2~mRsCrj+geP zvq*(+$8V<7h|8_M@FvR=$5HO;=v-{$E^S6C`h|38I$v_UyQe;u(S9bWK4k;_P2J=P z#FpUKLM5#qMx-7T6H=%`M#6uda^(}2t6XxTqf)uV`rLe6L)C2`(g)?J{`;tE5mJ9d z-&4zU^2Nvdenu%|knd*Bu;-Dojh>2?5Ljk!o@4c$e(rQ--J|+KcX3Z|o>KR(iuSOa zoM@V!z1Hl@IW+Fj*HH6b9QqPf+Ktkxr}gw{n}>#v-<*BA z=R3(asP7X#btovd4Qj2vD{9?8;#O9FWPZM;QQJ(b8Jd&-nX!VqIex-=T~0}OLUNv+ zlM{726MldHFFF@f*WOcc3$ODh1clzLD&xj(`c(@k2vBed#zxR0l!k{g_Fn=85=-$hQRa-WLKMC9Cu=k%$8e6$-V>;<>xok*uPt&-f*8RdoEhp+357dnu zyN^&B%Jq9()uXcOw3jYQ_)C!LCi{lphHDHHE6fG&FB#IjXF3uIDL*a8=zMLx>-SQR?t#|HY(`##4+-_ z=~?q++}!}SwAp$!&i2%zrGvw#@+O~Mi{^W#9*-mWRA-OWx7_4&1WVc5(KH{jGpE*> zF*9Hb?|sJ>@GrE7nU#iT25sTgi|EJT7k#TK>~EfAZ*w#6_4wnAMR~qh^&V_c%{rM= z`7$<%GASE3VX-F7CVtAMPcv=axj%erT=-=sPy%t7FcZS9?IcV}vVUhxw+HK!$Ml!6 z8M9M8XNTG?Sm#-=G8!MoI-ohag^#Uav^L=(dm>Vr$e z<>pqM*XU=Y$CY#ScQE?p(SBI?pv_b`UF>u9Dc7`THxv-aVo}#=|QO<<&`A}wDrH)BD zQU~dW6m@qm_5M(ga|4f1KdD-#3+nC4CHI@gt(JU9wPfKZ5tEsVe0Mdop&oq3*VyO{ zFLx+@)_Z$$x^9T%lyMOboEATalux)5eqt8&>R#%5pkCoMbGuM+@dniADc5gs(GRH{ zM0znA!N}tt6yc{t!95S04}R=OQE5xP{GyXxy26}QckEwBoKwZ+5h8A}bA=X#e|B##CiZ!sR?pd? zHVf8%7OYtCm3f~zuV=kx&Fd%OGUxRrxXgKd2$#(3r_oc%4HsxvqO~g)h}^`$33X6< zCa0RMT|`fiVBRA=lRi>SQrHf`Rxasl*3m{O1F%d91Uot^r5JWI89!NJQ5qw9=0H{4hRp08X#NM%;z#VW zWcKJ;*V`U$7%Cr(P< zNwwW7gQLCvp8hdUKQv2$~d2j z>-&{)eN~+QE93ksE*t6ozmPp(Rf(0FcI=mYsre3Wuv4;&4AzPf=6Z2<+D5g|GSs{; zjMPGGx)ovzTk1vL0Cz0L{A(a}H3tZpyS;@iAI?AU<#$D5jFVwP>Y{J(ZNzfgPNe7N z9?rdSc6^x8X6%zWVK{FaF?YwGk2Eh24{vVrhJ5>ehFg0arA9(bKihwdtiZVb9EB%R!aL;V#yNN!GoUW0!krrhf*l@8?Ay?dPRpTPh|OYiyuPda>=nru`xi#c^~eI1-tFrD zCRHAO?MC=UM-e`v(+<$vWN+q>F*V6;$KgZ9mC0Ermq$M{ zMsHe=el+WJ~M({-NvKIM~@7ojOFaYH+YL}5LvsOeA^ZnivMvQncEEF zIge*L-?)(YnY?8l^#ox(=fvdx_FVke5;q>0!MKO;NM9~}-aNv`#nM^>X=obqc+DP` zzV7tyrN-{1%tdYW+2k&peOGOi>|YMlT>9azj29Vw24@Fc`jl=}C)Oo82zGwfi&UY1|Jo_X>O5dJsMeS&OK?hjn_|c(=2g z?}lx4QaYLHHolhbHey)5-bl~p_hjh5>`ss?mtLH(lj^0Udf2ViWrW_9vD_`WKV^(g zbQpJabQq&LJB;eizpztvf1?&SYTQL?*t)B9P^x=#8L!=P+U}ul#|y04^^c&ngIIyQ zUdl(gJB%v`-(tBh!M(|XDFX)UoeKU6-0Lm(CAimF?y|6)X0KPh2?hPj#zFR?l5l0X4wUk-7q;XQ8Lk%KQ%Zt;MB7y zwa_{7xx`O9UNW1f!l@^_;62Y>nIS#eSJX{R{;_|i)yw?}?IUHc=djDAKc14h89y(R z`gJPx<@&rAoB`kr0B2IM)aTj2txz~6c>{2_or9C-v(@{-@q?2C4&U47(r;5ZzC1rT zZ=Hja=wqwz4^Dq@^wFx_l(1)|a1Iac56ugTR@qa4NuwE1a1_2Z0kl2WKKU=Yew`I60iIr`*_!`=i3~4Lc8< z3(mkX^OK;gUEs)_GjgIH85?E2Md7sPxxn$Afn(<9061CTWP!6+;p_(I5rtDSEDN0D z+^Tz~RtEElEL(kFaQdFbTeZboUvLhcgEJ4De&F;2r$XgtCi%HV;Y5b@1Lt>1=?iNc z;oTXtq*s{-LyQa5_N;#z4|fcXzi+JTc;9%m!%M4}47CQV#7Vp_Ymc$|jL>l^H09f4 zRClUPJ!YhF z+!Ow0=TW0N>C*qu<<`I7{gH7^=WgR!+W6c&IrFr#b6nsb#$OWe8lR_*8$V7SHGY(G z>+f~H%Z*e8aa-VhV>)des~^k#`U!XrHF8{=+VvI7K6bT>B742&`m|ET ziv97;NVQ~cI6Ty6AAMSudA4}UFjkYq95JHFOXF()bGd1Q%7(52Yp6b&<##CCN%Q+? zD@-c+P|++Z8dTWhTXDp=COHTyhsl>yS$0BhZ>8!5zQt#zx;O7%iCmTHgyi!wqhU|h z&Q8?NEH}~xIBtN7L){ddb)+fSAMM3vAdUH@TJ`iwG=yZ~Hai7fkW6bSyWNz<84#KQo?#ax>ZOX;$2Tw6Ov&BytZ+2~k=k@T6EM7s{T22`s zb=mZb5*BcD{z1LZ%X8=RMhae~q^j|0v#m-WTu=@XqHgS|_?O z#&kt>BZLdhhYH;oAg+_B9~%GcvLmC)V74aGDf!P-|1J$Zm9Xg0Fz&fOGzKPe=~u+p z;Qi3(oABz5DX)G5oXXNRVd7S%{((RX$I~3flE~$Y)Q$q=DPWt1nfL9;NYDns?#QJb$s5DHNUnU2r)@0Uk zN&CxnT(2~1bt>Zn<7eHa$DJjne~0S><0svdkL#Ad5&xszvrc}u!i?X9|3TuvubKW0 z_*Zv-xh=UASJG;t#NTsPyl^9}ENpQQ0pd1Nh*|zH{;zjma|%s2)$YdQpVKX6X6C`A zl?2R~FuY&gEi(^EsRZAZv_sQZi0=}xOyA+m54ds8ZTZ^p6u?`|Ck>vgdI#r=2#t1yt@5wLcW0MZe~h{wravm7FA7K> zM1NFrCFe!AIouo2j~tJ?WGefqxb+{PH(A4e1%2jt!b+}1=7C!$?CAZrz!f)o+{Mt) zaUWf43oLlS?%pnVxV3FhFs?`s?da7gv|Ad5^pv!%3^e0n=*O``%olLiy8|9pDPH`2 zc(QnU_4X?K`1xhu*AuKU-j=- z|Jj<9*>RtAq>OyrqRrQiJFiPzaa=DYWxjj>*Vd#9 z+C3bmzkxL!#K$5ps?tFZaF8dca_T+Wo_B4UQA zl(ZNA8cDG}7w-4s`W<(myv_SsN_#i&dEAAf?L7LBEl~PfySq;62X&+523z1G#pQq6EqET+w^HHYCf?r!>LS}uaaE?K1RHpNUGCPC`bfG*AF~Cne#_yW zf?wPAV527OK&|6@v|63|%Uz7SQK^fkbvAqSTBRL{uI57#r+!bDXtmmd58!@9CXq;`Xp`WcMkU<^1gXvKlk3hGPd)GJWI}Ti`+~00YpyKj67=+XKUpQ zcP;MNHhW+Za?8pSHrrhhX0(Aj%ggbtwtXv78oh&gveRr0J&3LAxO?nlq3ybB3Yk12Z!VIAmZDST&j{I^4_fJkE z)oDmEr>WZq>{y2v+1Y!@9ovjbXe{b{-{{*B2HJ)Vz^fvkaXP^szaqjMv$72-Qk(G* zPfcxZHMK*Jkuf6A~yJF_y8jXFTs2zx~85?*w)MYZcrF zJ6-DjNI&g5;ba68jb&vWKO>YxFGk?n2>*SjHp1B(F8Ad4$DF?};LJD}0J9m0#!hEk z+*@&P=@fdKas8rmAwA(~iV|K=xM)TnI%3jaf&XFdiisi}mzyWG7p2#Wvf547RAd&)e>wLM@-&S$m8= z-v4qUvx1R)abxn>acJ1HztCo*4dmCn{x4z`FEe+Xdi;D%`q*j5TS{aMaC5U}+ISop zYokMC5EdT%@(%*uD8L%WmN4(q=41Khb`xUL(p2aEg;o80!n&D=bWct(&r z$Ag38nL%Y!O5yYaXCXMqC%*#25yVP2=OLZJJxyujd+JOaGnC%62a$Hb5xz5Se3F(_ za|U>potx?)@N-BtJH8_#um{t>DL)tP?6kt9rDVN~xNjyn>%fS+2}>sOek<{Eq;xs^ zKbrrG<^`P3A*?N7$~^B!2hgi;wlE&FFkVPJcMity6-J3jNx}GWLL|pteF>IboV=gs zE&g?hY3BIEzg@ds_2;6$C9Q(fr7x_DB#kC+^0o!nGD_Xv!TpZBZHfPnySI;zy0{kq z=d-&>K6wB(A>a}sZXST;NrRw`E!ItfxB*(DqSq?cV5xVZXct5cim(CHpj3mUEh@Ir z(q2^5xCKjFsliKIQS`eBVDYJLZ>d2*-2k$i2eRMyna?L7*naQ-zhCm2{hXOOGjry7 z=FFKhGWW|2Dl@r*xqX6Lb_xSSt{~)3bjam|m_f*Ua5LmWnN!U)fu8M+0j=Vi?>pPjpkzl8k1-{A9$J(>fO; zejsF!>)FtLm{Ohz?GNboag}~Q<0?IebgL_Eyh`x)gXaftiN=$1&Ws;N;|jN4;s+@S zZ;{N{+mebjF9UiBtvTWCS>De$1rQ1|<9|v`p;S_Gj@+@9*G@CzZ7HF33fO2hCfsD8 z9}}*8yJ)^x?sK$`4Y=w?#6|@yiS`)#6qhQ|C3br+_oXznpm)qy%Blk_E6s;_MJVOX z?^bq-k8?kryF8luAKTO~lh$gF$FeUEKQlr(8G}XUM#k(NUz@E0Z~P{u&jQ_y*WCLT zp1@U@YcL|8lk*aLc#Q1*WqhB7yUgViag+Be)6`(qI73#F zF_|$v@s*}AR>jm*)qr*8QFIpXYHaPrm&1rQ173?9rk*;vz$YY;bjiXejg)1@5Kruhg)?+-l2% z8+MXgoz+2j-@HYVRx~-Zy;c=1u1$ZsqqZk8kynqsAtzzRb}j)bQz7^>m(e*X*DD`H ztfyhd`Wa8mP@~ikXd4Feg)lwnO=pgNq`S)_;dGK>SU$R{K5?>Mdm6lefys<3(EsVV&u`KM% z?_lc1s=eP)H}3bS!AyaM9JFf5r@9lp`mTJL%4nv&KDr|)v>Ye??nFmQVpradcImz8 zYKYZ)N0$v~Ju73~iT4=6`}(PqernL$vSQ7_9aYV>YV5m7S9m10a%>45@1IhOb-eR% zJ%~KJ;pbP?SEjf6XQ=p}lA;+2zTwz|NfnkJ_l@XA+3)%C(8Typbn-fV6I%O1iXIRN z^<00bf3#bE^;H97eWKrgU%!7}*meDWf70~bY3DmPCZ%wDN=6Q&wI^|NS2u6#rm0tg z;(m)=Zn~Fmb8fowTa$v^8LzoE?oFHh?TdrlN3EHOn;OHN_1Y_dj@>e2c4=_lEm`xj z@2uigl80(5c~waj&#Zj|h?Dl{Rkanhtn%$!+TTC}(Iw#Z-O&EpOu3(ZF*idMH#1n{ z*ImesT{&8o-BP(T-3Ost>}HI zdn|cz*@!CltP!EdxUD*9)}Fc0j0-kz)~wb!Mk!-@sfy=wg3uC?cc5hK>SlguVXl$8 zs&X$??xM<_)UB_xM-DoI)KBZK;LKVzK0V5N(Y4MPrKL+LOs^L$MxuGnt1{tadKLGn zw>e@4H=eH^B^ox619z$kr&@n(stJYBytvb`C&Jh^)zxjBG-Iw>b?!hj@;ujslkcku z&ZxNFII6S#Ok7>9qMt)FzIeH>ni;9 z#Iv3Fx=SNZR~~H@mkW0~t26I&%yi!=S~)}(P43G&t6%P%=yuF(yx&x~y=J+s1+TFW zPrEgFsaFi^^)hbZDakdbC$8qs+3INGj!vVYC|uDnFKjfdYPiZ%J?d#}Ee(E;e^e|i zx6B3mnA5_Z%S-HDwP!)Y6@5NY+viH{letiQWPQHFcCYI6FAQJd(D8`A8xM2UChb=m zX(HF$ckY&QIhr`1TzhB}&M04M<*&B;9i498uRd{QeRIA#SE;dse*SK9TG;G%#aqt3 z`A9VLXyV+?kCJ6gHy?R(v1`9eOUsF5oH5CKe`0xacV~P-Wqqab{%w^i#z=GI&5*gD zOf*j55Y_Rxu`x4V-;<$?NyhuiJ3W@!ofe;1rsFywR2@vNn&FHIbW_)=8AG}r>iRun z%GhYl3~}3^Ts_0s_&n=e2fq&WeA4BAo;^+~5lFqoD)}w$kUyXFga&VX3m(`Ieraj^ zmg3{9eJkk>EALy3PU*4BBI*KXlv#~fyOI+7&cnTrGICbk-ziALF+&xSro|FeCP;_C1=oKe=mxW1)YctI_$GWBq%{a=7)(q2X_+ z3)MJ^AeFc#r6OrEa<2|i&-D_nMrz4Hy$tF0#H^Z`2T%T8bUrS#Q+2i01&{?RKAO0s zb7`O{IorP^@bbd?`9~A2-O^s=z4235u5FgQRIzv7MtyGUOm}Cj|7UQ_f)3MMpWlJ> zE^D@hQNfv<49{T2kU2gkJj(Qq=Ho`UaEY8has1R^$6-)gM#w_u;PejRipIXe~;A)<5H5(k#1i!Nx0A&5&C9YwH&yMsygN85`>_znt3rSFCNF zF170N!>w=4Fk*s~LfwcVYXtt^QBJtU)nAy_t?u64 z{;y#&p49k{XKp;2DC^4Bv*n~udn&BDl`{WYv`ES~BxQai@n5`Uo*DmEmp5>KrL%QM zr>fb}>8SOo7ieoc*h#a?9VJ}TGF%+EhzzH=q^kpo6)CmlK;oZ0qJ7w^X~pjKqSS%J z3%GsRDy=M)NKeTt=HcxbGc&5izC+gV{K+`d<5u2J_-?`&Jg9f(ZoZ>6opEQjTkh$n zMNLiXRjKCAbZ+TeV~~40D^}{((VAhk7kw{Z@^q=-xz|;y_jfb0NID^Kx!DdzdTXA> zHk8DCF74t7_y5z?o#CnBqlsU2y+RvOyj>#SBMDFHl}?wtJ}kHyxTU*yY1oLm!k33b zwmtzX-mC%f4$|><_R0t&zG>Rt(OVx}8*H%k5Xi1uc+#1(e$z?uPRNO>$BgxZg_FL; z)#!NENqn4Z#edR;jv;uFud;U$9YIfbIT-me-nB5G8BEuR2QiDZz#F<*eQR96pL$)vQJM} z*9F4s!XxKYH>`2QRu+0X46~foKJTG~uYgZeu1+L=)?GiNdWJy1>0UKsW}q=Sk)vcM zGY{|Iu!c%&b$FlXj>jD_Mk#u1MRoN$v%p^+SR-u{Ib|h1(rTSwCpBrG+=xN>fz>|M zb5`uX?4A;kn=vbtmRyvo63>&x zqXlx8NUj){E<-1=_;@{4g-;fbvf+wC<$X6XnVrvpL{qP4KrZ~F44>m*e&F&o&RAX` zuR3#G#TrRBN4S&g<`tTrL6lA!a=cbfGRc{g(aMwm`BFLlSQtv)al^Y>vXaw@j6}lZi|JLud(tq zmRn=FHCB#|B@%5$(RNmNNPlw1{|eCWS>d^>K2LmldRxFz7ePDo+Q>_|$9N-XJ1)N& z;POcFzu4{foxWMzPT^~wIelx=AqOX)(Rk|Fr?owu9fk1Z(CHTvo?H_)H)osS+82^} z^7YG!$`b(xy#smVU}k()rvdL?pw~M^zDaffvdfei+$dV3eg3=i=9A%zAE^#&o3o4F z*jlD$aFg^TtGVSdReTBh+TaEe%N~uprut58+t)b|*WtZ2Rxx8w1i51{U(=ZPRR2KR z4uYA}T37v_+SWQC+-I#$@64D{G*A27r$haq`X+7LIRNiutIKMHSYXs z`1;s>bQW%!*9-R{J%*$)e#<*kk@9O-7N#OERSte%a{C|EmusJOggVxr+jMUllzdbB zzz0JgOT1o6EIeZfN)e^RzNY=g>y#_1;nx%U!n0E54F^h0%7K1^Z<)sZS~Xfuv3>n4 zT!*(RCS_Z!{l;j_^Q++yfq5C2Ijs|_M`~O7fN)Y`V}-ZExFIcS@~f4)!jWwmhs z04{&=sdkxlTA1-0G#@fEerri8uNR$|`sahZgRfvx~m zNvXtDcb*%K2zpg7ZLLq!uHr?f%=r7grR*n5^!Pm%ySLMe{XA_y54)$c5IZf5QS}_n z(aJ<~)i7u(L!Cn3#`|@L%@lWI(;P}X7ce^9*NG97; ziHy{j?J7RI=QzKY_I|B?md$X4*EFoi8-D z==}AJ72KW-3pc54C$-JJ{ip0Q9Ntvo)?Qh;$=)DW?i6x&E}RVKAzP@SdiMFJ5(UWT z?LG%da88%F70GP$zSf`<*6?Nxv%ZHLIc==WPMmbx-#PmGdE&7ycA!iMMx)F^CMk>b zkbR~AoUIH_&zYElA1D6O1D{jlo^jjxZ`^)^TXVX^DR^6S*k^Iunl9S-o6==wG}A1XwD%8yuSNZw`DDbi9hCp(dXGUF%V>DN%od(m## zl}MbnY%SUrNB*QKlr0*kY6r`2%@9(}0Sea+lHZWK(S`hmQ{*?$M5WL~g){_VGx&!1 zntYRKnT>vLR^!blRatIh2DEYWFX)PIkvjfgY5O%NXXt9tv3c#-wh+XnUHj@t-EAS~H)vJ%LTy+HQElU5Owzk@k31+vc5SBO8C8SyRPNbq+`O zf^Z-5)8tJBwnyaT$NF=dD>y!l^iJbmu8fPi>z%aD!Pj<%~_Z1hYoOs5R)Q&FA%D zQr|s-zGSEF$1QA7Vx;GHM3TG5&D3eOljc;Nr$gPeI{gX-3sp+uveS*k)uZ2=5NQbHc6DI02) z##CarO5^FIpH||r-3te}R~AXihe$a`=dY&wcf4;CVTMCO1&J2-_E)esYy0vZ0}V8) z=;nCX-<7DRoehdr9KU+;_L&jjRi16|MJpXI&YF_+mOXs6#QVhuFS2^BDcg!9#q;b& zlsZ$>|AiYG8!6M_-A|Fm&vY7h^n5+`B(@FORz->z_NN#i6}L`tqn+ZCtK+r`=C*$`v__L=qu^Uy+B!ypJJpAlaj2eUGcA>c`>~G`l1`LbtMjW8@}PB z`ybj?*Nr?&19$8g<-Wt(Ji!X;D(&+F-j({chB|=0rJ*Ui`Jf zR%xGa5dygsaQ1b}*=7rS@FCGTxG+VyDA9fl$(JrX2XDu=p^980BGanPg z?8hv^gfMYT2j*SOQcNA@IOYWAAZ9rxj5&$<67xQ04Wo@8to0FX8tRelOwo5`Hh)e(voJ_WENC z?ZsMuw6c!aNGWdCJKUe^-=FE<&k{>|AH}BysTrea9nfcqXM1^l02u^D~5i+V!u=J8)S%z~!9*F0xzwn0IkxonW#~Sj9R4c?xWD-g{syqmsOPI|0r@B7BsPUCGBH? zyYFJrEX&ReUMV@5ecIr+`gDPoF&v>wd`IfMm`BerV6_gnA=93-Iuj0FdqMX&5`OZX zpkwfz&eSnv>KJ~8W>qWw+cekNUpYj1D95>fQ{I~}GXC7kcRr@K{ca`vXBW4^?oJuB zEMwd0vfBKjo^nX#Fx81 zr}k=ST|d;2?LR(B#}>}cDiW;ac3gGYVQpVZOhXOv31zFIrsQ3$4d>(6lnevS)xJ&1 zRUT{gT9cg_-$zen1qZ~t^g!i6iGC=FOoAs{Rt)K^%yTr92Go-!ZZ4p>hMYh#4aptQ z{Th;Y`*v$cZq4oxsEoaje7)>lo4NYpL{8eu>Dt!uGz+d6^ZQDPIhS>oA5>sFJW4L|O_CEw%j(<%1lRur}QqL_qr6|7Rx-Iw( z;1W0{UnUyZ@w__1tQB|_@HSw6Gv!6a=5a-8$nhfOjHmF~qTM#*hVLy!8MZ8u!y$JfE0McZ3h6HoSi@&P=Pa(Pd_ zmU^0-lNo;`8NfCN+ngNH`%+fk;!$5lYdmGV!Q2by0M|@f@KkPY;%h2>ub%tg(C*dr zIep`awUpe-j!wm&B$R328sz+gmN+;zQgSm<6*(D){?J1i&`-6t0k|2`QqfpTXn8de zP6vFT7F}kvf^*I;orY{Pep&An_)kl_%8;b3(|A(ezaym@ z9ph3v#5ri@0_s%%UgZz?DCFZEcP?yeduB-?>N2YSe6-oHznnL z2-_j+bTj(ynKwV=rB^3x$g_vmnjFLmns#Q0q2t+;tfLu#Z08V+iI zv2B$+rb$}+*_rqC2imG0fvrB#tg#vEzLH)enjfZ966NUjJkvAgj~-Z4b1pi&rlxEA znVKrUNNOs;-hMi<8M>y*v6a(%nGr5JQ&Ym9LdS%zsY3Lk38%xVshnX_Q>LcU>KQrk zTdbZj82XM$j{u)H!TWp0mT^`Molgzzwf*6-=o)$hnLn#%-~uE);|QsvGm5<}Geo|m zw@H`Rnf)#0qurP5SYH08jLGzbp_aDO*)Az#+1pDQORth~Tx?bu&(^V#L*aG|7XY{!7|9+MT-q#*8qH1U8~K(_IlF%6Yx|k{y?%<+Z;MBqw^^HUAD#YJ0yaEUYIS!&>THni zb^FI!bvnI^zM-{$y{dixsKceT?$lqYO=r((|Q*G=Yu$`Uq%2O5)KG%)-RkH>UXC8WpvV`CL9;s zWMwluV8)O23N#a_y;nVN=~sXYjxLz*!+ZEH>*pY*FTKfxl@-?o`n$q2iElWWUC15| z_gf3tZ|ODHSp5wa$g7FrP$09jL`!G0za|~Z;tE{tTm#U)Gj1A)% z8%}nPWQ?1}%rTPOmrvysaWYa6E;Igf=Au$9Pwpb-LYXH*mr{Ce8MQ;@KuI{!ImBAh zDsgZSqT@I@#fsyQQ|5QM)hRQ%#BosH3ljZi4+6ylfsfo1Lt&DTknw{11JZye9Noju8GaB>E$p3Tgx(OU< zVNYNSW<3s0FssS;+NonN{*?4&^}3-yy~jweQOEM=fb@oU!-Lc5t+ms8P{;hhSJGRh zUBh;ID|CAIVUyN;FSZrtGGuq8CEr~w?f5RjODj&D`t^%<=oD6X7W0)hyy=rK8(ij} z>GR*Czgv8#wn)t=Q_F-kMUXh>IriSv@IaFU#O|Z^pl z_Wu$3X#1HIX8%8MBP|FP|ivu^w8=;9eSi4`gyqv zszVRAL+AI0b`-e?-IF+(8oINV@%9#s@N;BLmvLOi-272z#$_4b=VOk!;l~Xa$NR?c z-u61=-jY|Ik&^X=dHsnOpvs!8@k7RmhrJJJu3Jg0Ga>xiKO?#O2V_LkTRRgECm*nV z^J9kh;pAwfb3J|}c55C^mLjF=3L(oIMs~NcGjS&zTZ!pXH z6Sr^LZdt@po_tWp=K{Vk`6CTq2wyafn-#-Vp&CfVx1mCvMaAW@WTGo&Q85)NCPpVf z#YLKmGnccb&|#y3Z9^_t+YI zlZj7K@a0J9e^QTNrw)NXO!d*7OuU=2=swO0=y6)X$;4x)MUF(y!SoyU^uZ0lyMjNS znOn=NuNY(AdbDR&7d|>OH~gqTqaFbgZu6?xZ0YnPZ`PUEOioxOayP+O ze7}DGY;D9>vRc1?Hos(O2n|%p(Pgc*cR!tbiyy2ZzQf#L@D<&oUqYL&Uw{Kc!Tqhh zy~%wG>%JnRR>l`zG?sgP;oAZ~ijc&UD4eaP{*l_OrmdoyXz-Bf+4*AZ_%oen3+ zSsYG|_R2lhwANh?m8W9fpjiC^Bye$=VY~2R=>oYIBEFRi%#uj=i4LQCXwllp zbmoj*j$Cd;q_w(rsTxJ=!|Acypu2WgtvPQ!rMo^XB^|or?2vNWwaYmoD7R~N1xM7X zab^^a-Sg67#)8*_Z|eILx$_K0-_hLbuxe{#gMZXU>StB6LG6D;S*Rj7%G7mfPcpHi zw*c5*ID!)Ma1v>Xl$Dkz3P%c<@miECm=$w)*H8<$=oaXRJ{^SZc*R7eCcYc}XHcZd z<}GNbJk=^E4F8qdfHXZfds+=f^Hd_3`UmH2efL8?M3V3j<}gMfo7v0Qvi#TR5!z#T zW4M+6e27_&i7#V(xsSKj(Iw#Ig)()Yqk8RvJ@*BwLRW~KGVAAv8Q;d)@G_N#{IhZ^ zw6F3et{15?ufCJ<+V6=ww%yJAr06$UQ4d6`XLGc@Epc@>oNwBXbxVAZO4siC4g{}B z{v+iGxWbM=T4?f4iDxsk_MMv)#=OWXA5Q$7lPi(tE?0*W$2tW%r^5vPM8m&DqM5ff zQ_dp6Zc9w+{%vQ0U*yU^Ztd6^=id7nNpoM+it$c43)^yuGK&u<=IB@??mrHQd&hvd zf14^_8O}&MP_Eh%H>2&NEit#dFSS!$3E9&iQ}!nO{Cl`#!YLMKyV+4Skr&&b{xVKG zgImhX zFSNrSeNE)9nG?AmAu{Bn6f)i6oL^ju+^$3UY)#4O8bTj0b+WV5bXOGY>_i$Foq4MY zcpqAiZ`}Wa?xxgE?gD^^&gGq*Ir`UhtFHQvoyfKm${WUgu>Q^Rs;*VX2ZlGft@69h zg76UgzUlRHt1Qx<*qy4M;n-3=L-PE~W`4z0{9Ve5v#GY3H-{zGrXOZUm$ge-l;bZF*y$RA0j6Eg zl#uwRtJ~VGdmvKwR^4S#cOoC(o|u;^qRt0*iL^kb)%vMPxd(twl$i8~XVvIr;+luy~zDn7dli;VIFaGwwg*_CzJjmH?r6jcnf08%H;gL-gI?wM4j)B zmTCKky;3HVBIAiMBaTMen82#2ClTurjF5d!X@&m19l9_o{cwctb?pfwwS|>qno6}> zaYlMGl(gyg#0$L!7u3p$IhzAmarv@WaAdZmt$O9QgDYxkpP%)H9}Y8f#t|-vr2K+fL1%5E+mv_PF9QF<7Cg`ESoG0u(d zi4m=$y`53T%NSJFR&e!5N6BN|CyrkQRmzg==QEHs2(Zq;<^9~7m&m4 z*S(aJ=)`wARk6~g5bnunj%(R^sXHXI$F#9dZDb`?tm~fBb;iweTQ`z-#p^dlk<@$& z-9kT+(k=W+5;ae@4BGv;h;JKuk&Us=m@&qIq_=bIC3f2!nKI6Iwr=k%)w7SjwQ8U1 zOQ?8a9C91OqRqjIpfN7@0~PdgM)1F-Ql7Nr4Y(CmBkia?aXv5V73r3C4E-|D9rXrt zxbZWXk$(s}CG%p%v;@ITC3dBoXfFRbE$pLj2NNN8wW4;8*Uh`sAREBdhlW zY4erqnepX~xv53Y_2*PO)`uf#cjbok+uX>jn(=i_U2CG9JH9fG*v z(Qfm)hj;i?MzycFJ@Guc86Qa2=p0#NuTqEqJj6UUSa~md!evs++_2Iu?6}(__2g!p z@~h>P`(S3gyntHtz=+&{f01j%5a7#4$XzfhnqL>SCZoQL>@rh-46iCHDx+4Ja?N`3 zwvoY&SF|O5jqAzQJM4Q~%eSYaYhakl)$zJ@yo34ei}y^dl7ba4H>7-~9k0orsx7e` zms9<5_T73-ky}PQ#@61^j#%#`)tVYD?dDh_+&zx(=ZQ_HFVrgtGyaz|5-MI9$Ih|G zu~C#Gx4x9G;1yYab=Ai!Mxir<&}Q6|6d!T-!x!n7WYOV=+u?h=B|Iwv!b^Xu9HojR zbVj_B+hpR0s}60bTTToqzU9Pum2iW&2W&?76r8v3gA9GoYLdQlHEF0S+m=6Ln7*6k z{dAh@I#?~Yu|CaF`fk>wwaUV?!pQqIdpsVwr#0y<@Z=l1!b2PiUB1(UCF=XLOZ+*@ z1_iG@;wmkvs;XTboF^^|-VRQz`Vr<^%jO)p+*MMwy7s>pPB|HJX5LplDvNisuQ}ql z=D%;T-p9F))qk$Kc4n^M5v&RpRISFeAb)LCU5U&U6zKV*K6q8!FzRcavHD=OS*_~v ziEmS-YBaBFj~lvgcQ9l0%N<$i&auP0Gfr*yZ>{|OnmqWYKzMNRKyLNEQ zwIE}(b4+e`x{c!;o!gye`@80~MKZ?cwN3xQc_r75O6w1~wQ5h~>QQMWdEL(Axm^xo zn*Kc>Z~qJe*9Go@^UlU?J8vMa>w9^z-3!kviF6D~I~#A%*9YS5z9mk1OFqLDlDn2g zVWgA#bC3QZEBBK%G|)%&`v?@eBGsEh?`f*VRbu#KWj*LC*M&Qa1N8BA3I_B$`r(t)*wpC~H4M*l{9-ljY9yQX8=7T+v%*>Yv-xAr1#sksj zwgpWC$eVT>@#olk{*qH3xh3u|6q#J^yLdRgTTlk;-28`4l{(TBJgRo3bd+WyJl?&wYalPAiZHe4Dz~Albz+XZw9^mRH)a{z{aod33MH<#8Qnm0o ziVXXAfrj;O7|qJ;ajW!irT(2U;P)~Oe^dWju=P7vyXct17CyJ+hzDt1e#`Z*6-w){ z3(M)15w02Vd!@i3>-XClwtlU%GV2#vNpP&+SsJ!}XKL8`t=6#hi~J<`)-Q5zz$5kV zIr>-UF{JZo|5j*s>lYbk@VRHzlciR%7g~dP2(u3J4CWEc1DHlk17;KE3Cx4+``2Q& z{x;KW;Cm=)cz=$26XvIwjhMZ-MKO&S(XTZ9|8S4^ZS0uY|IOR%xF5uPh>2kiV~%0s zm=)lMF^^$3U^ZiZjk%k&>M+YN_h9bDEXUl3S%F!J31jLpt1zoEYcTg?9>6?=c^I<} z^CQe7m`5?pZ^dgPj*|7=CrFcMU39a2MaZoka`oey!-)yH(Mrcgx6e zKYdks?@tz~3u5Q7llOGw8JT(G?vn3D z)4Sy*A&JSQV;aP7v5vJwWdWCJc(ls#`j)_>&F}|RP7vs1I#AXYpkqLXmz;`BChnBi zcSlC-R3sPp@4!ZkaCemF1n(%%+H%JicPOuKX|6Z8RPyFx-@0Y#An)O&W*_xRP0D z=@_F9htfAnm~o4Pi%A!Ac(I>6LCq4OkyAd&5tJgOVC4P&jwfoEr!;#%{Qxn~-d_D8)QWLX* z>OHEYJ~^gLL&f#UvEFc`nD}v0TJ46$FJfd(RVNxdWV8^Qq!o}88>2C9;^N1pBk_&i@5b~=4k<|v|H%5m z(7%1Twm>Rz_vzoTGT9Nx0rR)qIcNq`#Se8#j<&H5+Qy23+ZuJxfxjhyjAAD; zKDEt(5ctjdY;F@83+3%ARx$Uy47MZI9B|{9CtfvUsk@(>B*LF5)_(%Fz@&H60|q4Th`KM$+aow$bv`&?E?Ss|myvHm*Ng2wu}{HpZ`A0U5o4b;EVa}Ctb zL5rgIyb)2STxLvCGlx6tmK)D-9b(PpY+W09+x#r@+1$?} z!@682^W$MxIP&N0Q<3YA_|+-6;g0B)C+n|c|2szT4@N7F7rEYTCj~}yh2EM6n~|B} zpuu`Ad+u;Eq~h~9$v&Pq&G=h0oHxF_u14i`ip+UP#%+JP!RrpZ@PIr`IkI#^jt_FH z_?x}*zSP9w_{7JjM30Ev?L}_Pe)r`f-b3y|a!+1QWCexnp2+%1y4~0hY5RxT{xSCb z+P+uYU&Fpz+oM|Mj-9sseIqSJZ;`thyVH6Tw{lMfIsUX$iH)57N$Tqe-*Unar}#qV zp0JKhzX`5m3u(KgK405w`%{~v?enoK{XWigpqjWB%xT)EMyD&1M6*eEJoj^u93tJh zq^ndzb6Sj&NJAcenCQZFXlX4Mx1*0ImQkjq#8&1z(WXj^Vw;)qJZWV~w2H+qN!=X3 z^+L+*qV#wL+zaN`i!$PalNso25WJrJisV$aIZ_K9ak)=S>!_%mU${B4jdP^;SdE02 z4%RV7k<{{|ozKGE{Z-r_9@{4}XN)wp%(O0NP+p8~ayf!B|2A<4d2PhGB_l36OB?b9 zY7_{6u`|EAGI%`(re!1YCC^PG@8YuN^i!W1S;s#goVD%q+N_Sx-Cf23jk6KXim*5} z_RUgeVBhw?VBcqV*5F8fX!@Z=9wE}O4K1xbcVhzC7d#^(d z+z%`-b;=5W^#;5DdR*lFR^f!48@o^AhI#+-oCCtW@fX5v3IDiy?XvmBS5-MR?-mMD?BZc z@6TMtDt9J2BU_LpIkAsh)w)mL4L<7=`U0GdI{zqn6)Z^KRI&Mmha%?0TiO-`!uJ|Q zPy5ZvFQc`DemBw6D=F8IMgv+Ot=9UV*tlz1S=QGE`%Bwya~;!l>E_1c1}?>o@CPlZ$xL?X}!=2_hUJd|L9wB!rM>Z=kjGn zGh>$reoo6vi@9QzfnNZrSgIWfF(9}!cKKa&U>dMWcOLkf&i$kqT1Juen96#hta{Hf z(X1o20dKQI-n5o^`>+S_8!93@z#XAiz@G^TJH+Dz0Ci~GkUe) z2_xmrNeRChs#M0SXJ-XINPJh`4dCS%^=ts!e{@+P1j`DMp-heI$2TCjSA7%c*Ih2| zuYZte>hcy{!uRLAI3TCi;(syrpQ7Qv?`;8tHwWZx0drDGoA{rP|C%mux{Fr^#sjbD za>l$xKA?NM=BvA)&>9^b)>{Qv72|VzmsxZk-y6EptGKDoX*IlV{l>u{Md-Rzq9rxI z(5EgRCA;oZt&?p()=-nuS~Fw6^75`~${RX^^CdV)i7C8-{evW8wYVHWHG$gK=a;Pl-DE2G0LyBb8$-CL9MY@0d zKwbx_WyiI1q1eN${|Kq#AL$$6|KwcX*qL`8GyF9}YxB+3!Ny8cbmzb^gj)V~h>Yv^Be1`{*4eeaO38?!Qww1{@gE3>{%`|Gg3hW_S) zGubN`W%_rV{`KkKvHEw6{vEAzOMf%sPe@EzFkN!PJ{|?u`H^+1BG~M<$ z)Bc+FH^cs>+ut<%>*6aXvQnl~b(!+cpZz^QIY`e!*|dc$p!vMxV(MBromeGuE&O>t zV+DOk#qwh+=D|>xF$Z;Oz54JeFG(3288PLpjCd-MmP%v&D|IOU<$+78P4)k06T0HM z4K8!eheOOIPrA%^H@VEVpSa9#KIJmgf8jFoUIaejGG9r$%*vcJbH%VUle0pzpg7I^ zpYzkqPcRo>fVn8myk&8k`AmMg`De`4<1)?XZp<{_S(IrOKay$Q1)u#o&mi-YpAIpP zV|ITu#QZbn4a}REy_k0}QA`_VKjvM`LCpJ@4>5nk#4vqwg@=GY!5qdM!5qVUj)`NA zV@_iJ2XhJ|TdZ*@-dR>Tgmn%rvC2>;l3ajV#x z41*PUsatTq(Wy!*XIPpOhV}9W+j@FDMy;3gWm)_p@y&})>3aW`!QG7@Dabv}Q;DHH z*)jCdkgmiUFl3!?#p>>qG2a=J6tX&fUYBUCMKfW?m1~+UsfxjyK1xnQ(%RqjQF3~- z8ht8pTx;QX51{|ECz(AisO5ZsoHQxP$q;h#Vs{QXc^L|<*q5`L z>5Kh2IP!gY*_`xwwZz4vA!Hul9y9-)!|1JeB_sgJ3XZ@K#`yKg3u{kB zva7F3jzK@QiIqd(D}R#KbrlGXoDP=K&K*gwz;dd44szEE5;7~{}I;lq}8wAz}p$s}EXqUmb3=z;?u)mjbtB<{|p^!z(gijJOFuB4Tm=6>L5^aTZ@UMw0Kl}GwIltCY6r)XK z-PJhGYeo->iPXEJ73%NI0Ol1ZV0EVvxS8cGFy zRq%w|VmpSdES^;GgtYxb>~rD{!vrI$UH0Nqb241Uy?E@x1LcIkof(`A7UQlrmsqxF zdlLI5>@8^Jw`4}mF}#w?D*sf(Jbz>>dlOB`C{|?W0@uLd8VL;Fle`*=6=m&cQn;89 z!*KJPel-*~YjvFuL_hK7G3xAb8V3w+GYkQ%CEYlX#z_wA%pm*VAx1Ran;y%=7Ur#^ z3|8-^m(@8vh(0vU;dfz5jQ_m+`L$oXodX=+ZoOceLfZ33$cQ;(sl;9lJ%!CcyO(@L ze>Gf*L4M8wim5eUj$gl_T*5uMo4GTS!&|`XdHr`j=Jj4@{CVtG^Q!T!=%ZM{TfwEB zM!Y0>mZ23K$|k-OVK`G%2V>8& zZNcX0K`x5=YLT@u^}QeM5Ej?(4fI1~#Hcr1EPmq-tuX?jaO}c~+k##8CbT`=RJ!VT zFl@ySJy*6B^hmhSrwTrf0O zFxJ3r!NsDnRAYFxUAQ~>+J2C?r>)bUy(7)gH1dG>9U;F4bP_)+rHPaoS}Sx)G4Pl( zv8DS;NhxY;v)GM`mG@UQ#y0FV`V?uawr|ZgG)42ZyPP-8#a(VpHtHBA??h6&$S5|e z+`5DZlh=^Ob%Pt!aV*M4C*erB$1kNlN2mA&z5#q?MS6A&!-!$Ju6IB6oKUAv%>eKd@6brY7S;e zXyNfj3ncCsVJWAAOn&!|&#UXpSCAOCf@_uRWT<)-OsT_dTIm+H8+CW|m5q0iEzGFSUctAMEy0n6&8e4QvSh@2M|0GhM zt1)!`HOBsI!4SK&YPiZ~Ux>qKq0J}6#Qr$FIz+S|V>cMmDoKU*`qefiugEXYCa=0Z zg@9x{mG&v+GN1Nz&~v7JN-lfx4d5&7DM%{Po(_lUq0lHAJEVP-O*qp&ZYPC0Q&NzV zg+j2TB=dDXaaT+IlkjLQ0=$)NR2s#|^;wlv*NN^MF)U|J;@)N#3VT6H=tX(u)P zluA39u2Ys)TCTC#XxKT7bNVCg#H%r+3_KcRt8Pg`>t@|j-{=p~LI`Om@pQ?J#Cd4A z6!F{;eBnzhp+IKsU3W!txO{& zX)DLVxIrg0kC3+F9(Sg#gh*vJ6k4fBdr8v5q(tMiV)`LAX)kXQ$A_lXUJ7-NgpPcj zqgTZpe^)tAdx^Q|^>%+*&8hw`Ny z>M{gF+DzyiDPy!4V3!!y5klI`t2%_ZH0uyc`!RxGNSmqAw0?DLkv21p*w3^X^jF($ zrc|fp%^>~!zBc2=*UG62UuiQYDM_2zAEqVHeyGLa(q@j0In!nqk_tL(>{O;uV`%iy zZDubmnpF@sX*1FWc8IPI+rfZsbgezL!)EX>6TZYZZW3o_A2e6mXw~hF-88w9edffy@c&a8-5&E z+Q3{*hs{Z21scApCh%V36JER&_*=j+?*9lp6Zrk!Gpj&ZdnR2iP$c8hvHUmm+Vc=D zBCShL$3@nfD@akLFWxV4TtXZ>?6@xmj@WTe0p2tymu51<`Qj0MlcO%2uBabK_F zuECb>D%GKf zy@u~DN=w?W+}$*M=SLUD9Pty~j=1R1IqZBdQBFxn>wPaVh4Mj?BGXOp-W-`{=IY(q z?h`Gn`NNS6UV)`N5VbMF0rIp>OK@!_W+|Udv_}Pp%n{#0+@cq64KZdBBQq#aTJPq_ z-?MV#9^)1xFJ9}&t#Y4?*P2!S&>bOPI_VpsG&c3ilr!gD3Fu@D>=^xr< zs*^br9O;8z2^C855dZFM{*N9mPG75#xrmg^|W!d?>jvnd^1<_e5Sp zS9EUK6P2I0nsB5zNArfRkaMOjgu4Vj(c_p~;BPF%Y{RXV?;^}0_UIqsCo(hB`IckC z+h5QvO?7MtrxJed=c)Lk;mvTI{l|?W(=WdbydU*gKqz&@8nrwRC#d3Iq5ZkZ=WIn9 zOZz{p{W(FU{wq`kuZKTu`>fSI;1SZLL%MXxM{NIf+Mjb;i8)utoGURS$*yBY#)~iK zv<-6mauwfubg%zmbY-9p$Uxf?V@SsL4lL&@xHLB zzfdH%rUN;Bzu#A>F_6z9ZbO}q59g%~+@bCLCNSr!wD;ov+&yz(jK*}RQhYDaa9CN= zTP?)kRpZIsqwN!Qtoi-n()N!d)^WPD)V`H+YRj5{IKm}BCE9)E$)zt1)-k$N4zZtO z$36`B)^??K(+;J5&ZiyvX?I`8+zMR5_Zt{#r$OwMz|%07V&pyG%jByZ{@d|eijgs5 z-Ih#K`iQjQDohCXZ}MHjSK9gI;%1+7^nbYz&RAM8moYPs=|$l00OzpK6!<#e^q%XE zq}e$HXPKnux=Z&{TUtWE z^tsx`0}m-OD=$PNzyqnV_KCc+m3pTojg5`AUCd}P^`cL~Lq*zeMC@GrstZRV&sPAH zHO{@yqvaKcgURg$-NMcRhMNQ&R)c`$)RkH%Za1#7+8->g@P=MW!D*t^b{^oYiaHZs zUjup)q~4yRe&j6kF3h=@Ld-Udw2!Rnuzq(Z(|&))wC%3I%u~;C8X3C65tuESc7eEx z=yzdEO!;=BZqB%h__YsI)UB!eQ=MZOv->v+LX~{y^IgTamTwE+xf9&Xhu3HGe)kf_ zY4&CA_zA}PfOhw1t7X>8tbBrdvG5OXitdX09&nCBV`aD{zA2mrbVGehyr4bFLmg?|ReEabbCS?b`R#nhEiEG?cL{h;@d0Z8*2 z@xoqmpC$S3p&a}L=3@3?Su(DPy{v#S&kMH&en{;J1O8=UmaHs2?D;INNsitFnps!! z0$jyv=Il&?jMeePou|J@yw#IxH{$J3a(zD~HG`H6pkz9fd`DCA*VAy~GW#e&=Pi^p zXZBIDd4xsDCU#R6B^xq@l6CB{EK1hsz2I`4zEHBXpOP{tc|cS043tE3q)aZROm^qo z0VPrjkCXQF{??)iJzpdOI_>$SEqp&K z?Lf{_JM9}u`wg=%->-Tk-#g5{d~fww`QGg5%l9Tz(%xY9<$ImpQLWJ_O1_u(r@f7| zvvk^HNLzS@R@!^B@3hlCm$Ya1r|s8iPwP*+%ud_apSD-0?deb3ZSUs#YG3uIeHUr( z?Uvd<{3`vfKkb_AyX>?-?x8L+`trT|9LaY}Mqj?Sonz&D>p6Y--kc%%-lTU=!mrz) z_g3pN`qEybA!&K#r2U9a`#I8vvqHY*-Io1Xcat`9`Gcr!;;mnt6(ddj@81Q`~DB_%0OWcRj z`*Ql>aLMWZ^uC<#9sUM1xrm{e80s09CT1-owIH%znLf2IZM3w|K#zld*aU{%`qL#R zjXG8-jWs&f-8n1c%NZf#i5olrk$9?;^=^*EzZIUgwet|3w$qyr-@PSrBJtgxM8c6u zBtGTt1pBtSu&-(#cN@L&#A@oti%Ya)rK^%NWXD7g5+;lQ!!wszG`Q1^#o}TP-(ypy z(sw~sIoj|JA!}N(WMjMB1@iFfqjs^w9ZWM8i%WD^U${5YB%C7LR*_L%vYd9a_YX?b zaT#=MWVa@C6sbLtE1>P79)VmyWj$BM7X)3!>8IU^ z#E*ItiKXN;Kzv~z?|JJKM0e^`JB3j?r=rz)DRFppEEh_;xqs7StM(c+Lt-n$J}qkFDIo!*K>>gjzrZi7eIzLM&b=#B*$08+n zUOUigLF;^>_wSU)iQmIrA#BJu>#SV*blCk!ukN~AxG492C6|Bw{n@!}gEqv??Kx@d zP|4+HXJ3EWG}OxF2I8~YVS`h0xyIR-%Q_87E~gOFF?}+^tCy#Z_%l!#rA^=4pF67_ z8Zy0}y{vt9-ThYJ?40>~|3S_kAROEia(3BSIjbSu9|;#uUf`z1q%Z$U&K71MC{30P|WED^%QtZq7bC9d+ zXSeC~aPL@C^2As2@VC?dLmo;Axt~@Z@=dezP#-T?#rT(YpG~zvt8>QAu8W+mhir-) zp!h+X;`=qlYix>FL2*54$~-JGwJU7um-kcuL#Y1~r+feNJL(@A?(3)in^T}Hu5Xsf81nCGb95)WGu^M)oh{C{ zDa+H8A)Tn(-(V<10!`N@GH9VJn=-SXvWDd6iNB?cc=wKLSi4`1xfU}ABfN+Y2pjf& zVN-RK`fcCwE^Z;;HD~pm{B#*nHl8bOcBT8BK>b(x&ffn^*}Dfcb)@~{b52gKgb=O* zB8H0yiZ&?TsI4J^!$r5Cy<2z1YF+GQi@jL1?HcfItwjZk2(E4Eu3Bv|Lf2ks&|0fq zy9>76cB{6r7j2VDPe8~?K=^&;B(Uo4`+MK-AIX_BGtV>gJo7wr=JL!lM{ktGk45w@ z!9%^ml2No*CF5E}w<6UWsBehB2b9zL{uJl0FUA#GrhFE9&0obIpVKiAF0&Y2*U+#Wx#YWD$E^Oc|w7b`%=- zAMH3tf@w!CtN17Vg8Vf%&`5-z?ANy=W>TohK53>!zghJoDUG#3Lo{v~>8Eim@cC(c zE{M|jlmtO(d{ly15|rH)F_+S~AZUojnZS%mJ<9L&jDu~#8+N*WvgRfl>t&QiL!iF? zQAb38M%XCW$4fNcdtKXqolhYI%z>=pTl%E@wKq}t%uN(NfqI-6o>RRq&8eD)=Trv+ zbE?MSIaRGRr>d49D1{p(h_xDXSGGi9xiq_?t@t<0*5U#bz5@%2EZiNb|DmHFJ*yLnIhGzG}Z{*WE<# z;0HIhs1LRJe0cVBMw&gH7@j@7ADBHg56_u;iR%S}{nKwYpr7#NlOAkCE=sv)`kJTO-}Gdx#1p`vn&eL6r;Dw`#U zgQ_7a8&yMc>%c55M_LbuUozOr6rskD_ww~OP&r+yaVhXyMOx#0>_jfWo1e-lfWi6& zwDXQY`&)(a>%qOC4FS4t{2svKONa+Wal;fvNcGbWQ^bKHI!f;!o`DI{4D1(a&PFM6 zV9pki@1Jq}>PhVT4*uIhrL|hRQq|=#4*1svRnoek2cFZ2a1k@nTFj0%4AZ7P>(3p7 z`*-`_gwF|_m6!vWmd-{9r;)!@noSM0o`1a4FO8fRpl(+2S8yXov+<_(JJ@=ol>P-= zHV)4>u``E$$1ptKj0ns(>Fmzm?{E^e=uZOecU78U{h}E9e*7SXs8*6|*gvABdwv}x zLK$j&6e|N8hbi=bKjug^-iH~SzsB@d*(ru!J^#4&1ElnBKv@A*mKt%L{!)#lea}-8 z)F9|wpx%U%uxivwgj)eK2QZs(g2F$mP)lDbhcw&xb~^u0masn>$m!?eQ7LDH zlrtn0eW7~uOi*ufl*F2tAMQ}sTl(XQ^tZQ_pq(x1u#9Kmh5i?ba>Brc+ zN}LtSBW41u%9=6nHmOMY=3%}kNZj}w`OxyHkyWHLrUvkaOIVsEEPlKiDW>r{yv((; z;NAvc{z0186yLzTatZTSm=jsW(ZJlMeBmbUJ^cQSGWZZ?n%IpC^dYzh1>CD2p1)OL z{zf%!X#KicbZj{I}s8Mw}etoH%c-4q<&@=sQN{*1yl{K99FBo@>Ga)e92C5_8|^>jlb za8osE@~s#>oEjmeexG21426#ObnH738fXfYPVMQt7 za`k<6c{#AXFU@33!s-B@4HCXNfPdpUd^06{bQOx?!|YZ5;&og$D!+t>%71e?_a-i9 z_rU|UBts#_7a)D~a5LaP4fYPusDb7m3&7z(c z`}Rsa+=Satv+=&Jk4@0ySwYtu6n?HZ4nx;V&{sU?`+Gf~4m=&;#Usf36#6vE*N6Ik z`3~z@n4i3O6JK*M>Zhk6hxnQ)%>rghJfd`@{2hh!*u-*6vR zFZD>Z!+qG6z#7!r;Xdp+sSkT<)VCbb~2CiSal0l4P3BDmrygqG%Tep+uw ziO~pCzD@VpFYW}T+fscuNWm}CsNUa?`Dr~b#W>K@V15ZX5aF#w(tlvXZ66Z0P~VrA zi$Q12MY?`bmO4Lx(<;1J@m&6Pa0erK8H?wCpHUOxIn>$Td(qiUmDGD}9PaO|f&LD+ zSOxmKN2UHQM>eF13t&}4PwQcCAUq$X-AC;LO7IqV76+cNCXi|aKQDN8dL9{QlSWz$ zzL-&cQ!dVx>OZvZW)&t>%*o$@oX4bG|5NQpdH<*NDE5Z+sK&r3?~QzaZTA=Cm%Ty1 zJSF~r%$E_C{>%2$Flrb(P&-`1k9P=|*Dbtskk1bWVzj&vSE9q81;)xiXEqPv< z=pf~m)bSnp68^ED@d5nQcEFGS%77pLC<*_^68;guf40wrbHZPGwgUf~eI1_r`^N_G zPX_)U1}01RGg^zFGxThF8^-x@IM2RKJQCVwi^ZAt?V>Fqj03x_9AKD}lcxF(&_? zxIeei%{ExY6i@xtA3)pIC?rjPdi)3bJvBQn69 z5?{mrMZkUO>BOzC{&Fnda99YTAnLOZe(pyXs4VzlHyo$K5=df5(us1CKDr%y_@$v& z9g8}89E;SN4mZc1vjt^mmv1vwmdBbxEoz1>51ZX_7gJsk8d}ICQJEc0!m(arhW9!R zWV0Yt`ycW2ycj)mrLricGHFeGa&6!oD!GVr)buwvI9f&H5{!kRq;e%0H>Dk?txIL4 zb(Zn7V@t*d!f6Pz@U5mnN~}dwl7c$3rQ0mYxVa-a5Kcrmd!;^2+c8>-3AKzu3~Uuj zNvX;*61C7dq6*9s7MyIcs7e$LKTc9Q$w`Rh)e@QyjbE-!$X-qoDwe}?0Gv|eOt%cj zt%K;3o;DkY(`K-`A_>&0sw_|Lr*I~NvoMTFg`XC`2>j?dypW_&K?ZL(jpQ}pIBk1D zubXq1m}H#nWLf&AnUfs7Pw6cY_?HsqI`v+X9eCOv%EZql=bl+zMNr^Ckp z?pOHtDSq6~eBD|8IbHC=hO_<)pp%PmnqMfPZ}ags--k5j9)yn4_(gXkbOfjRDK;4} zz?=Cno*^#+L)Z$CH)|LhkGIJ_ZK5v0f>0eoAqgggY7im`wW>tHkd(e(b||$FCB<w%kZ3wboyL`bXr;f z^W2hS4M|zxjm=cX+C>HZCL#SyezATSp$lig$5Hivn-k~;6?HG4>E#HLuSlB-O z@v=ObQ1M>>X9TA}ahjB{1bT;Zs?5t>GHvf?Wi5w&6<3e=*7T&0e9d&iZIDm$$$KYT zUNtQg2!F}MIv!9hbWUQ|#v;Ew*>2#|_!Ze#KVwM{On*p1St~Q{AO9+AiO?F_DJGk* zvIkhWB{9uzgW{i`*(jczt0n@E;q!oLvg{-H~haQ|BbZ^R}sX;HkBy*DTu7 z-voSZpDsd=gUgy*;P9JpuUmN1L1cJJvKe1sA|W#;Zi1%=2cnf={=Q$ zp561uWS|ENk@}&ECU9}PwvcQmbtw(~HncI2&yJL+as)Ca%NA>B>ZjGH8kr(^Z*2;8{G zn!-ksWu%YA{i+vb(dE`e_$*^4`53p#5-oYWEW;>nuwFBgA;q& z$0^uA&Y+Su>gOI(P22dQ=QvIQ!xKRs^`z==8-q2<9YRRxLZ?Zs?o$d8Mw;*ZwMst3 zx7qhD+J`}HLL9|Bji1}kS#z!Htsh&tf{GF*p`xNq)K}3owBd%0@UP(a((0FltbT?Z zw5pcT`&m+ndfCQ2){#oicryAkTHCr$Fm2uI67e*Jy3C=t4+=dFR%>y_0wWxx<%S{6 zFqm||WpvVE+;BArujjMqT~}R$N%tYHsjpk0V^w%{HBoCrvJvB~d=viZeKepFcS2A) z(YL5c3O5!jpVqw_EBK<`wlcj_ttR_^^c?A9YpuL7|7f2eD9AmCZ4|jG!^WcCf#oWb z!AfCMOVbKAnzd(BOHBm%Ja!v*3pvY;y%)L5;tXq(9Y1ZHjeWa~W_d?yDfKi?b159D zr7?lZUsoP(jX z;4T>I6=paM-tdRg1|PgRjr==pomkw#f0*N6CadQO+x& zOEQd&6$oh&x=lxj2DXuhDjykN=S~3+8Wwi{VP^2s7(#u9 zU|nTS$!e1Nc!%MMGDFD|^9*~RkR@?$6>CgbW$5)dt`V%Tsge@;71H}GywC4II=;Ik zQPHN7@>->|PmngJ18XY}Xp+Y9{^?$GxmKe*XI7Ta((X4=v^FZaQ5LDVxZpv zBSyr7o=WV=&Y9ioc^&KI-x8DX5-~i}>)A74c%s*{d!PjWwF7(cUo+sq|MmgHlf9mo z21@Y1WneG?!*gN3~$CG|O zC9J0Trh+H4Fz@X3lwi;8)O^YTEh8TP&aUO-} zx5d5_y-QOTy{oWHwTq;M+NqyOG3N9O1##FJP3u_G@q$JJ8Vn791qFK5F51eWnDfLO zMqe2NAGjs(W3oMRd*ps@dtph;F8LdD|1xG*0sQ#I?Alabf&bIx$MCOS$t*|w%53~^ zT3Lbr(<_fHXSav$4?jR0Yu{Ow{Gu3PGA1u5vnJP<)g_-VQzyqQ|4Z_M<+mo+FW-<{ zd67v^hh*MYko?EB!YYpDh6EHW!JCm=fR#2=K_kLet{&mcf*%mBpdyupBLGS}WYj)gvTFXajfWMK(Pd*!%M-jv?&7{~W zek>HTzpm*QWx(c#@#FGCQA~a)ipdW}F%3})+mQTZlt^oay`lUi2yfuz7ggyg0c>iC z?qNzmY5oud!ZQO9=Mgqal&nPUuu~+_F$MKI2wuLCeBPl3M(n{!uzsA_E0mx?1)#6y zQ9hs^2>+Bvxv&BCT!|K$f)?@9aB!G^Z*WH(8i{}JOK?LN4@!^}BluFbA$f>rv{ruV zX`TFhqS*X&y}@m91OeL+e`!k(b2!ivv}XR?*VhXi$fNwDxWIut%D*?bhaAD_6FNSS z>EKv!NrR|0tx)sM6Y>{DZE-Me%3)I;FGsK4R^+@l{to9E?K*^OL>BK0@cyy# z@v>jbSF7`!XOwT1$-89o74etQ4&lX1)H%+NKvlR&S&!QV?2!j$hh*)_`nY%G2O|%) zooV}smW5xj`prf)C$QW{-KNNNOK^42K{+pbt4LtAH6rJD+^JKo#aDxVIo67t^<|7z zHaT^=^&)Y+jP$Ke6~Y|8Eb>5J26-9lp}4i89J!gQ#yEd|2KnUFa?sz-yeK(^$ z(-Bfn(oMo=R&M1-D=&feT*W`j_>~^el%sr6oKv=8Ws&pCxH(Q1IIlqc2aNeP=#MrM&WUGpt|B5Yi=4&cN`Q9Su zd4vlPRv=uh(Fg`jp>s>@Y^O$Zx|m?^s376B@a|1ZjjayU4{W;H2veif?|6gs8Qro6+c(cR%xDnphRIrEj^ zkuuN8k2ukt4Y^S&iwn96p&`#0UwUZj{ z6mwlWfyVsUKszB^0RF|(wgQg}&~9Ih^tVSYXztgX=sp%i+s)7We6m`C@5FDC;$x*Oq-Z{pGKz@szQ@#sF({ zG{usvrfv1&@*GIgndPnM<&wDtUj(D~d;gsVG2O)Bn>xXiga3)9wfMiqbOQfI6Nj%& zhA9XClT2&zKiOn*P$(vS1bVk*32ux8mmdF{`txfM}wGy9CMIk3v!%64lQ!bL5?lRac1R- z<;r?}!;&~<^+EGs@7P0Z{gODgTAx1HTmFV>*Nh_=GnLbkwSPQCLxC|BLjG|Tjq{JK zq9ZkfbaAcdwflbla_gV1C6Q($AYVWzA{bV02g!TDTWk?O7sZW~XaQ6vTHYf~@ z#SYMdPoD9|8WLsug8+3OM%P30vv7E@M477wN1Ij-jxNS;;Bqvb&lDZ+`QYghJaL&> z*%Z=Ke-GPJKkrbF`uXHZ6Ku&-IlhkH$djZ{-pG%`O^*574~g-USYbhb>{aV(&Xp^F zrd{4sUz}{r=CgQKDDLNal;znx*R!?+p6Z`qg}nY|F=Z;}j+UqK@cuWI#+s1xR>UVy z%_wX{YLW17x0t#2Y8B=vjVF_CM@c2_8!e@_9mw=JGh>@VxuvQzZ2=0_rjlhFt|e74)o4V z&M@$1{#Kq7LdA8LGw)PO{v<1#=8QjTpOe(;H53Q!Y4s+X?i#<(epk{)UddAq#`5EN zQay-$%m~cmg4-jnlDmRCl5NxZY>B(6MzWKs=7bm#t9+8jM@3IqiK6G^B1KR0ylA5) zBXJTD&iit^g6`D!$*!L0ekt?Y%fya$E7llEA}1VthlZQH8ba3>;bW0k@mk!K$O*aq zik`ZAxKx$hklegp;hsbiP$nmgz+R>mE3*_%)uJ(Sxb=hBRPdz0^wiyX#A`H6dT%h9 zv(D~fxE$;4lea{JGj~1oQo3yr_e-x%ms`Ux;4aGIBUmF$k6EJ6v9go6$=o<+2d-M% zsJ5}jFdHYN4-nh*)&(1LtiN8~wRQeh#%i_>rNv8Wd&TuJw9XTL7A+hf%+Gs=1E0B` zaSv)T;wGi?tv?}NSoIFwKb-a;EBvO9>)BlVxS(T{iAE!fvprnT`BKm_FRyp-$?UFY zAq%H|Z|;4=(1?>+jbdh0qc{n_tdvGEXKJH36Hgw`+wsiD(}ZUso@PAfOjWtHDw3j` zR@D35%Cb>7&!4DtVK)PssB|gxGQ6jX?4Ovatf20bPrTB>^<4Zt*0g%QT?UA9HS$Co zRf%Io_9fJ2InCGOlTGaEDC}Y^jpF7Ruk~0LH;P*V&#i%HmGp#UFKraJ&&cm(vizzn>+jmD7lhi0$ zQ9>C?-Z%rRTuCRyay%bIjh@KL=`}1y-e(%cr?QHAg(n-u606{;!5 zp7+Zh7e+Cx@S>0Fsk)P-;4F4=qj>b;M)6(z)-I!Y4GCYZdt6Yn27b`fIskc@3+Z8X z>p$7>ifA&tBAW5b!H>r;-(cV$7b2O6L_pw{p9CL!xyftx%Wt!c-*gzOR0(?llVO;@ zp>D&!HoS(tm#^06CyYqc+hRBDS}(1pzO>+_BciGJ>zDqumAI@5&XvOv7f%{V1a`ey zS0zha>j?JOZF8eH;g-jX@PC(>7|fFd4t>#BAKf8o{b{=Cqsw%iGLApuH5*@VQbG=+ z_@sB5y_sYT)yFkSvv)7hCVam>6`CXTYZEH)Ot}`FxD3x;yjyv>JDPC9cl|*L(Bo^_ z{0L~}&;273;6XLX%I|egMC$l!&EBbo=q$P0$V7FJi6Iwsvzgo9w$;V4E*{ollfCRM z$@^%Ze8ik6R>k#pOy_9{6Ry2;Im||T&wB6o(EF;-;VU;JSXI`d+q!dnt)*`c21VzF6vCS->0}oWWNBgDHUHzH6g>n}l;x|8=#5L;occ=GdFO zjY`@Nke;h0sus>D6S4+re^k~Ym-@0O@Znppyyxm-e_zH$f?Tz*rk$B(1!T7^rqWRx`}#D zuI%eGZX!QqOSd(7i`$yb7|YKwUbu6U%^RVQ?2~mXT^89$ZMb!$En<_ww#IzaF5_)p zmK?Q5SVwZz8$ZMfygZ`G#TCiV+q??X>*js-biUDc#wC-DjCjGU{5o1D7xsumuJ236 zSL7d=2J9DzYj6Y2g&k5Ue}fM865MECq`Pp~tI?Z!|7O``rsW5nKjTuV4!cr|6kmU~ z>93cYddNZ=|IUT*%}r=atUUKL7ms9R>sq~fBW~U!qB(G*}`&5i>x=-Xn{3XfjC=~Ir zK8|1L+dS|IO2TiBqOQmp`|uwQj}UcD(-({owQVCrjpM$YlAN*}g0YARWg1Y{s=kWc z6L$1!!2DTx%*Nk>RpL}5fhgnc7l#YfmP#^#TWu**`olw6)9>l0&mCUc6H z4dR4lzD8T3&1RPI-RDLK>JUZybZ-<<;%gFv66gD-qn{Qk$k^NYUoU@!zV8S8=s5OJ z&*bOHm{#;(!h_0f=TQmCd5r zsB8#!=cvedm7R=t^bnSIOKq+PBV!nVR+p@)-H) zqQdar1M>)z^$9d`H@++3ee3``^#kNTY7cTVK}&PP`(y;Mp+9vfTx!;&H+P4G9qTTV zku;1;n%F+lg&f`Ng*tOv*RG0Yuel_6Cz)sx{#kMVo61^}s=E-hYwGO6c*am=Qr1~* zGMAa5--j2>DPkD$cKl^4YY6de=r3~0?-&D=`H9krju8*Bi&n5>buFdO5O4OE$qyGJu0x<|``dos$= zp60Dc4~sybZsmkygV{Xc?Uj@ZM7z%JzU4w&c-shlln12#vR^1nKyMeR?Llm z(ZnWv)MJ&8=wqfGcN3isHiPv0wav6FS{;$#ytsUI+CKa0g!jxzA{!UpK3QZ((o@m} z!1Bx2**=~7zvXjvC>!JxV5MK7m>}ygC3Ua+v$((*+(5=M6UMH;yod;i6+vT)gb^xr zjS5e7P?7M2`cu(h)zqjOGdpG5_^~&XJ4c~QJ?qvRz{cXK!xq+9}a4!#f zR0FT8GG46b9wDR?4$ zXO$&|?0|oF_;#OeRqPx)igPEcReMm^oyrtuC+fWYwBVd1Bv#It;>NgR;>`3T-q^NT&TQE|0DaW;7YtEB7X(D^8F*{-FrDYF9 z6S*y#1b??EX}va4fm*#HzUyW*iYk?RqN=q++klaa-aJylhcxJFCngkU)%7*eK2XfamPrhI=nWj%A-xgUwtSJUy~^p;?Z z3OV$7mHp0TY)xFhcs(&p$9Pa|(UM5ml6>n)>W9rq ziQWN=A-u))D`7E0!+Z0_VJnk{JRW1;U%jyQdmNB3H%rNAZkoJ8q=&u^etneAqDsrT4h}5hUsCLSk>xPA*|P1 zVq3imgmii{LL5R`eRgar@p%5&mqzFvzTbL|^~+(OLTsl!w+two1lXqNXCLu$##(di zxnP7;#x>^1b3q6xjJwS2*Q$cUuw7B&U1QvVcdpRp)fhILW#`!0yB~dES#2KEN^K@? zZ;`_>HQ7gZj!BZPO*=hR;?O;P453yW@^)~bm{gN})RtpfD?^A~-QMK0x;L6m#~tfg zyGSi(TXohrH^GvYLP%lCw%PT$$a0ZOo+Cdu`_AHZMOy4-}mX5#vbdE5E*-R z9x-JXWZ&gxxJNJKsh)5XbFrI{xh`(*D?QfG1@>&GmT798ZLhN55+W&*TKn`eEc>-3Hw)cGjose$NCrU7}AnFx_r( z>SXVlmc&(Frgeyr>hL(|#5Zrm2$v;fvpt3%;mQtaxjaX)M_09_A3`i-ri8 zpA0@d)J`|H(T|SzvyXL$Gaq(`%dD}xvT0j!XP3mANI|wW`u=RRo3nT>>~eZ#eNmyW z_9>qJ5*9rBv)QvN;%`VFkoCnQT^C4~oqf~I=xB~jz)&@Jg`9V8op>W2>wn<6!>Q2S znCHKi<&pJ`Kv~KupGkH3y_+btc4E$h#lq6=FUA%*<1>z`A|O3s7h081Q*O9)#Z+EG zd#t1V@*=d(5mqnC7982cAhfnBA5)o}y5j7s*3dvZC^WPk6fCaMVtk73i>7Fc%@k?T zIWp73&z}VMbDbvnV=9AB(G_V)@F~FiVDMflO_EM6BecTC1F|W!{^OnP(GO$~OHQvn zCTJGqMnUC9;g=glqEFE~-9Fj!t|{*D4>3#PCtqG|&VbHPOG?fT?dxrf37SbQDQ~e8 zpThkLwa`?cd_ZMb_L^pnjJ|JfnQNRvD0yVkylrxGfl7btSNpL^f!n3HaQzlV$tbu4tw z(PrA;cduSJ5#f3*=96(n&Y9X{WVxGU&v6yQ#>+21ZEUnXo34F>o+9U?#cggldQR1! zH95~bcgAhNP4QZx%uP%*oPe;@pJ0pwOEKpeU@0J>D3SXLZ~8%F8~UA7BVYw)t>=>q zvP&w50&x^lC&fGwh`~&8IgQmwu`7mRg~7=b@7hOHssTIqMllgdMZ zf5P5}Aa7-0Cqghk^c79GqIhAGYHbtN3-}OzE&plE9Wg~ti>6qd;wToUS&PM~RrAEG zCPinJQ`uRyS=Cup$97h|d;SWUPh21Ai0fk&ah+7Nu1|uV?)-Dzw9b78>aQ>l@43RP zs=dN&-gSkkJ9mYNozb~jGqqEhRodr3soR-ny4`>JPB4ziC!>e)90-&c&;~224ultH4um0A*`_-!HrdSkzH|>IyTC?_^>>xEsHNJFUobQvP?8$#oiHlRJrK9rAIV4$UT%wIse(OfOy?7w%ivt#zxkBz^VO$KHB_ z;HzeA6;qA7RqPJ3Lq5JuXtBz+ZBkL2HqcWHdgg;3Ipt*yaD#`4t3uo-a!T75QrxY@ zpbv3>laJ*QqrsS=n3e?0#c!Fd!n0P!rPMMmtsHHE_Lx#tEY7sv5hF)yphfD?I(xwd zw8BT~K*Xc5Yxq1K`;LOB6EL6pO2srj^3UO)?@ zm9i-3w_ahgDA$2gOSy~|%o^L7D7Av3^I{g|{zl{((^-i;AITM+OcuBZ7&c4Zc?{{! zLU1z++(!CIIXEq)gWFl)bk=61$r^r*@zcHbvn6rAiGST}zdHXdaKyM<;x^g6TSYl- zzdHLZc2_%U*M5b2xcv&ds{M*$^AI&vpuXygd{xyI+2*P%%DU_2&Ki(AD>yx)^AnBr z3JW=0EXg31C+iiNCbRPZif+3*z7Jz@1mWC|;2E zL9k!u*C*BgNuQucPBrvNgI1J5_MuN`u^aUXx-@?!I17E+j8?5f>m5MLz6*UqJ;uaN z?^GAA>I^DGYs6-DCdWdbVxQ^!Da)@DpFWi#}t@b{gsYG~`ymd@|Y)Elbsu~phMu@(uWs!zJh!w<$R}E%CodHL1XEx)SN~-)u+t=QJ;+eKl(&< z=SF=3->%mu4f=~>&==4rXx+Gf>yz;&eYzvYuTeA6!%?l8x)=H*wFvFu&?>ZdfnHG^ z`bbUn2raNV&;pce?@~?=wGid_X@gU=s_KofU_pGFmftKfv^JcO9NrQ zz8#eGO%>2Lp(TQ^!2XAhe_i$4_UWTuMorKwXbkAVN#|aTa#TyFNxB!ByFl0D*CUN_ z5QDMgKl4r{V^^XIIhn(hF=}u-Vuem>e~;yIA#c!{|0V9R4~6Jz95dI3muiH#i$YimfKkW z%>MTYf@rG&drV1K2O&a)ctZT)=@a5l>rRNjJd_4&bei^r_jBrnq|};6-*UXtimIV3 zFAnS8WIv57yhd-Oq9+^ay-%`sHZ`bS{u$Qmq|_&UxG_@-)%k(~p;n&)HW(Df%1{hG zFEK<(tLD_oeR4-c&u`1B#n4b$+RToM(&NjvnMa&Gwyd&rQ|z%t7t0x(RzYm(rs!iO zGT#yX|MG9uu#nI#M6rUy8dyyO_Q(tY3t5(D#kzpwChtUiR=tvy$Fw zo>D!=y%n9wJ2I9z)n}Gk#i3|CN?`5-sp~ zzl_D1C!CE!>k&fW!<+71kR(%}2B$qi!#Y|0IqUy_Dp*1T#l zoS`{nQa+k$ZK)E&LakzWD3@SGs2y_C2Dzbk+ge-N!TZz8aMGyVAEFr9K%4t{9#&eF zN3mNa7>e(-4SC1RL;SySs2}!2`Y{#+-ezG|!4PYUGG7TAE0)M{`h2fAM=#6g3YbOT zc<#fkgTzkPN&5A~P>-jzMUhV)`Ns3uz&D<4{jz)$!oNqj2B&OjKFTBPPo>BlB)Qa7 zVpTHyt#EDdr&USRGcH4F@IA;s@aaSW?7xq!e72DlT6QL)8*mhWc-;EO! zV`$zBc$=Af?lRqd7QsV$e&=o5Bv|+!bjFfBi^=Q8aNgqF{-N=K<8``}L@LZA4JCj@p# zk&Y;wfsArlS=@Clom8jc?dA034-K6yrzh081N5XMwMV*qPH!0H;P!{Qtjt_d8^;|8 zqp+eOeXeOJJpH<`DSf+>(JplMFCW5DocirKL+PT@S4+PyO<6|9#yY}~W3rRc?Qv?g zaW3J}D3?}o0c-McE`{P;R)By{UZF|AJ-aE#I7*`CrS|{x6WlD1U5eTTE(6NvSHjv}A9o zK6+n?qcj>llVO=LI(5-q_)-~Ljy2Ks!nl103L?;2(|sZP_7`YRYui*aRMWMIX+*sb zYvKdMAa|(uXD>KyQ6H$di`toaaKf%6f#BBgvVjJin#3&?rLe{ljiio-v@ePouhn_pI70|e;LV_+Pn*-2u$;JTmJc4^F0DULn5<~U} z1Nu%t@0H4)H1J12z(q7@-%%KY=48VIr`>dks!-93}J&^>MNn{~yx356Vc@ zO7zAF`!moEx`B)XBlgE3REQRdcZ}FS7aF71F$Y*Y18-VJ(w4bpfp?AneOnnL>C=b< z&?CbqWu`cJ>Nn?@00mpGrK85<12x7O-9U{KNJ^l_i6mL7aS|bh@ebfZi4DLs*W||^ z`m`T^L3smCLJh^v4a9CjY~pb2wm|G@#3l{Lc06s0lcjc?!}<%Tejv$^$Y8uM=-F{C z8>=I4k2=Qv6~FuThp0+$w?QrTDQ4o^h12?maE#Z~IA@zk&)Eirip<}du)fsYUX~X& zI+32J4VsHHUnRMo_OMZ!v*g`+^mH`GbURjU$woWvcHabJ_Rmed{W5gcBk#S|sGFP}I_QHB)jvd%XGFkV;Q%fI; zT|P?gs+4nlj>z45(A)>S?Cr$0hWy!OR_NZLx#?F$vdvMd>XmyQ(mx)*8moG_T7^rg z#)^gNA2DQnMhEL2#EidC^Sv_oi>YE{Nro6{jKXg614PzCEF&W*RVp{DTAMRNWM@nV z-f--uGCkJp)8Vv~X(Ahgm~L5*)p9PpBzGKg{oD~YGR#I2@C{H7dg|=NWg&artmX`C zJE(2cnx^1`)j#QFK@Cib!l&xpgB^CJW)iR6P3?W;Jhl0HZBVnzz^{xp^RuyMZ|hU? zw;fiymMZedBwH#hbvWUUYd9w;SyTxv)Y??RZ>=9|i{zF2viQ-kH{Gyf&@*mOxsTx! z`3-My!p>_<^-J{|>e%Y4dh)WYdRskLy}jPZEBBA*<*=x_?Z{v zw_>jbr;BCXO|GP(+rGw*j#14WbIG#hyI;XSNt<#(9f3U_a=3@A-e-q~E+_C`Ya-Zd zNIPmjja_l9>AIO2YTHH=iI628bE_B`Y@Cud!sbD+5W*aBIYQ#7 zAG+l-TK2p^*~iXdT-Hi|#BOX^*F-HctqJS_wpzA>6W;E#!U|1xfZCKb^$~4w$K!%l zCfmXHo?}(uBiY98k_k#!Fv+1itWCDN+us(jc@Q3}Xxe{p?2eGCu?-i*eae*WY*iv3 z+|#)@ejBL??rB(L>RKHcQp?nE!ij4k4M|lk-t?3U@KJt2ESoluC@0a@XdOtYPii3P zhiqeNOx0n zP|rW;+*%#i^OvXLJtX;4aic@vVFz-H%GTmF7%zy=ji43>tZ-_8nb~Noz_`l~*(_S; zYHbEs-#j-WuQyDx9b|RMqpS&U2(H)Egf)zOc?r=~2i45vVXyKhRZUFIs2X*RW><9GbZFn!Ya?odc16?; zdNy5)f>apyDpDvK~lKWx@`nTG^nkXQ!~~${Le!%^HSwD}|0enm6)K=~MQa!)n^PxQZk`b`Qtj2HPt` zEJ^CR@8|p2>s7*73a^p(vv~FTG?sY!D2I!9Bk&=7dL}qvg|r>vQp~355hP znJ1KjvkK`d@M;m%Me)ra^t zc@dKTg@n|903q`uW zvQqplu+_vlb)mz$3s7Gz;WC4J9E;^CWB9%NXx|Hc++^z4vnnr>XJ%^L95dRtwx4lr z(cXi-YLf709`ZT+cpt|s&GmLzv2R&XX6;ilZ9yhywh8SKGTOKGDwEk@*0^vNitw&g zmHhSPnSAUe{qFDX%NJz^+Nxe?3Y9r~?@6@L=|vX)<4d>mu?^QQ!8XVdS*zSN8n%6Z zA7hC|kM20)orlx(a=}pdcek8DsE4?%#TUdXqRXp*~&bIWof;kRR>x!GRHZ|37_ zr*e_8cYhuQ4;Trx(T8=rRB5F9!OC}CayfBttGr$V6H8~IROqdkPg=b53@zR#jON~T z^d<{@HHrIad?l5ztPQ<3{YZ=V9^_e}AIirHiffL;@%7EHNY3uv6&7RLW{x=DEKW^{ zZwSMf#nSzc$uid(*?ieZ&gS~w|5dfDaenvY$cWd)sZ)b{7Cj%_V||QT?8G%3h`qW$H1CE5;lTo`@?o@UtN2q3vrzc{&m>q;YhA*KNo+ z4Esysj$IS!3(bQL+%7ikyz;m_Ch<>C^VB`g8|g z=~HbYeY(HD(npx(IUPAT$9Q{N&>hZ#JE%nEh^k*OqSUG~Tg_)Xf_u&{<)&u(sT&K7 z3qS6Y4^am@dv#@yjg03&U2|p3e^Q6mY^V&6jevKZ-L@j9p-?t?=xZ&TwA%(L$oo`G zZ_@1ejDOjt8biO_dA$qDi-gzIT~zL8HH*a;o4sYB^lKB%lhmX3HjJmhJ%O2yl@F}2 zuw9jXYV^7BeX0T4XWtqd7BLcKb>cKfyN{WIZ~L@Hv6wkzYZS{e*i8L|vmGRbmi#q8 z4gJdnl%KeVjvZ9V^!qkl8Z(fcI9DPx`IyW`n?8Mmtra5#Y0PkMVttD^lhN_0=aVho z+e6h2q?(T7=JVriZQ-o2(?@0df|%-P@m6NMj=VE%CtNvUh(%BQ+=vr6MeqPQ;X2NS z__p>;we1ye58W$PW|+JGF{v0)#dlkV@$pjepU15xG zkX6fjKE^36V=jebYM|*$EfNI5m;HeNL<%7017ej?Rtbb z)xkr}V*HE;5b_;r@#dpOSs9Ym3Bxkl`U&329DqwZpyp0wnah9Ö)i4bBQ6oH3I|| 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

}bTpBX124pYJ%<@l|9$)L1v<%fd`yoDm&ixeM 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⁡CyW|XuEU@I91SRK;C_zvG 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%0Ay3V$z&nJkmY~T3{{+wzr^7X$ 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 vJA$R7GKUrZd8rp}x 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

IY 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 Wro%8Bf0FOJAAG&@eoF++KK^fAb^q@G literal 0 HcmV?d00001 diff --git a/DMR2P25/DMR2P25.cpp b/DMR2P25/DMR2P25.cpp index ea78620..949a9ef 100644 --- a/DMR2P25/DMR2P25.cpp +++ b/DMR2P25/DMR2P25.cpp @@ -190,7 +190,7 @@ int CDMR2P25::run() { bool ret = m_conf.read(); if (!ret) { - ::fprintf(stderr, "DMR2NXDN: cannot read the .ini file\n"); + ::fprintf(stderr, "DMR2P25: cannot read the .ini file\n"); return 1; } @@ -287,7 +287,7 @@ int CDMR2P25::run() ::LogFinalise(); return 1; } - + m_p25Network->writePoll(); ret = createMMDVM(); if (!ret) return 1; diff --git a/DSTAR2YSF/CRC.cpp b/DSTAR2YSF/CRC.cpp new file mode 100644 index 0000000..e19f429 --- /dev/null +++ b/DSTAR2YSF/CRC.cpp @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 "Log.h" + +#include +#include +#include +#include + +const uint8_t CRC8_TABLE[] = { + 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, + 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, + 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, 0xE0, 0xE7, 0xEE, 0xE9, + 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, + 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, + 0xB4, 0xB3, 0xBA, 0xBD, 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, + 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, 0xB7, 0xB0, 0xB9, 0xBE, + 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, + 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, + 0x03, 0x04, 0x0D, 0x0A, 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, + 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, 0x89, 0x8E, 0x87, 0x80, + 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, + 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, + 0xDD, 0xDA, 0xD3, 0xD4, 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, + 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, 0x19, 0x1E, 0x17, 0x10, + 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, + 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, + 0x6A, 0x6D, 0x64, 0x63, 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, + 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13, 0xAE, 0xA9, 0xA0, 0xA7, + 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, + 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, + 0xFA, 0xFD, 0xF4, 0xF3, 0x01 }; + +const uint16_t CCITT16_TABLE1[] = { + 0x0000U, 0x1189U, 0x2312U, 0x329bU, 0x4624U, 0x57adU, 0x6536U, 0x74bfU, + 0x8c48U, 0x9dc1U, 0xaf5aU, 0xbed3U, 0xca6cU, 0xdbe5U, 0xe97eU, 0xf8f7U, + 0x1081U, 0x0108U, 0x3393U, 0x221aU, 0x56a5U, 0x472cU, 0x75b7U, 0x643eU, + 0x9cc9U, 0x8d40U, 0xbfdbU, 0xae52U, 0xdaedU, 0xcb64U, 0xf9ffU, 0xe876U, + 0x2102U, 0x308bU, 0x0210U, 0x1399U, 0x6726U, 0x76afU, 0x4434U, 0x55bdU, + 0xad4aU, 0xbcc3U, 0x8e58U, 0x9fd1U, 0xeb6eU, 0xfae7U, 0xc87cU, 0xd9f5U, + 0x3183U, 0x200aU, 0x1291U, 0x0318U, 0x77a7U, 0x662eU, 0x54b5U, 0x453cU, + 0xbdcbU, 0xac42U, 0x9ed9U, 0x8f50U, 0xfbefU, 0xea66U, 0xd8fdU, 0xc974U, + 0x4204U, 0x538dU, 0x6116U, 0x709fU, 0x0420U, 0x15a9U, 0x2732U, 0x36bbU, + 0xce4cU, 0xdfc5U, 0xed5eU, 0xfcd7U, 0x8868U, 0x99e1U, 0xab7aU, 0xbaf3U, + 0x5285U, 0x430cU, 0x7197U, 0x601eU, 0x14a1U, 0x0528U, 0x37b3U, 0x263aU, + 0xdecdU, 0xcf44U, 0xfddfU, 0xec56U, 0x98e9U, 0x8960U, 0xbbfbU, 0xaa72U, + 0x6306U, 0x728fU, 0x4014U, 0x519dU, 0x2522U, 0x34abU, 0x0630U, 0x17b9U, + 0xef4eU, 0xfec7U, 0xcc5cU, 0xddd5U, 0xa96aU, 0xb8e3U, 0x8a78U, 0x9bf1U, + 0x7387U, 0x620eU, 0x5095U, 0x411cU, 0x35a3U, 0x242aU, 0x16b1U, 0x0738U, + 0xffcfU, 0xee46U, 0xdcddU, 0xcd54U, 0xb9ebU, 0xa862U, 0x9af9U, 0x8b70U, + 0x8408U, 0x9581U, 0xa71aU, 0xb693U, 0xc22cU, 0xd3a5U, 0xe13eU, 0xf0b7U, + 0x0840U, 0x19c9U, 0x2b52U, 0x3adbU, 0x4e64U, 0x5fedU, 0x6d76U, 0x7cffU, + 0x9489U, 0x8500U, 0xb79bU, 0xa612U, 0xd2adU, 0xc324U, 0xf1bfU, 0xe036U, + 0x18c1U, 0x0948U, 0x3bd3U, 0x2a5aU, 0x5ee5U, 0x4f6cU, 0x7df7U, 0x6c7eU, + 0xa50aU, 0xb483U, 0x8618U, 0x9791U, 0xe32eU, 0xf2a7U, 0xc03cU, 0xd1b5U, + 0x2942U, 0x38cbU, 0x0a50U, 0x1bd9U, 0x6f66U, 0x7eefU, 0x4c74U, 0x5dfdU, + 0xb58bU, 0xa402U, 0x9699U, 0x8710U, 0xf3afU, 0xe226U, 0xd0bdU, 0xc134U, + 0x39c3U, 0x284aU, 0x1ad1U, 0x0b58U, 0x7fe7U, 0x6e6eU, 0x5cf5U, 0x4d7cU, + 0xc60cU, 0xd785U, 0xe51eU, 0xf497U, 0x8028U, 0x91a1U, 0xa33aU, 0xb2b3U, + 0x4a44U, 0x5bcdU, 0x6956U, 0x78dfU, 0x0c60U, 0x1de9U, 0x2f72U, 0x3efbU, + 0xd68dU, 0xc704U, 0xf59fU, 0xe416U, 0x90a9U, 0x8120U, 0xb3bbU, 0xa232U, + 0x5ac5U, 0x4b4cU, 0x79d7U, 0x685eU, 0x1ce1U, 0x0d68U, 0x3ff3U, 0x2e7aU, + 0xe70eU, 0xf687U, 0xc41cU, 0xd595U, 0xa12aU, 0xb0a3U, 0x8238U, 0x93b1U, + 0x6b46U, 0x7acfU, 0x4854U, 0x59ddU, 0x2d62U, 0x3cebU, 0x0e70U, 0x1ff9U, + 0xf78fU, 0xe606U, 0xd49dU, 0xc514U, 0xb1abU, 0xa022U, 0x92b9U, 0x8330U, + 0x7bc7U, 0x6a4eU, 0x58d5U, 0x495cU, 0x3de3U, 0x2c6aU, 0x1ef1U, 0x0f78U }; + +const uint16_t CCITT16_TABLE2[] = { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, + 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, + 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, + 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, + 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, + 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, + 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, + 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, + 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, + 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, + 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, + 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, + 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, + 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, + 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, + 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, + 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, + 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, + 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, + 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, + 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, + 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, + 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, + 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, + 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 }; + + +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; +} + +void CCRC::addCCITT162(unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0U; + + for (unsigned i = 0U; i < (length - 2U); i++) + crc16 = (uint16_t(crc8[0U]) << 8) ^ CCITT16_TABLE2[crc8[1U] ^ in[i]]; + + crc16 = ~crc16; + + in[length - 1U] = crc8[0U]; + in[length - 2U] = crc8[1U]; +} + +bool CCRC::checkCCITT162(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0U; + + for (unsigned i = 0U; i < (length - 2U); i++) + crc16 = (uint16_t(crc8[0U]) << 8) ^ CCITT16_TABLE2[crc8[1U] ^ in[i]]; + + crc16 = ~crc16; + + return crc8[0U] == in[length - 1U] && crc8[1U] == in[length - 2U]; +} + +void CCRC::addCCITT161(unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0xFFFFU; + + for (unsigned int i = 0U; i < (length - 2U); i++) + crc16 = uint16_t(crc8[1U]) ^ CCITT16_TABLE1[crc8[0U] ^ in[i]]; + + crc16 = ~crc16; + + in[length - 2U] = crc8[0U]; + in[length - 1U] = crc8[1U]; +} + +bool CCRC::checkCCITT161(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + assert(length > 2U); + + union { + uint16_t crc16; + uint8_t crc8[2U]; + }; + + crc16 = 0xFFFFU; + + for (unsigned int i = 0U; i < (length - 2U); i++) + crc16 = uint16_t(crc8[1U]) ^ CCITT16_TABLE1[crc8[0U] ^ in[i]]; + + crc16 = ~crc16; + + return crc8[0U] == in[length - 2U] && crc8[1U] == in[length - 1U]; +} + +unsigned char CCRC::crc8(const unsigned char *in, unsigned int length) +{ + assert(in != NULL); + + uint8_t crc = 0U; + + for (unsigned int i = 0U; i < length; i++) + crc = CRC8_TABLE[crc ^ in[i]]; + + return crc; +} + +unsigned char CCRC::addCRC(const unsigned char* in, unsigned int length) +{ + assert(in != NULL); + + unsigned char crc = 0U; + + for (unsigned int i = 0U; i < length; i++) + crc += in[i]; + + return crc; +} + diff --git a/DSTAR2YSF/CRC.h b/DSTAR2YSF/CRC.h new file mode 100644 index 0000000..d529271 --- /dev/null +++ b/DSTAR2YSF/CRC.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 void addCCITT161(unsigned char* in, unsigned int length); + static void addCCITT162(unsigned char* in, unsigned int length); + + static bool checkCCITT161(const unsigned char* in, unsigned int length); + static bool checkCCITT162(const unsigned char* in, unsigned int length); + + static unsigned char crc8(const unsigned char* in, unsigned int length); + + static unsigned char addCRC(const unsigned char* in, unsigned int length); +}; + +#endif diff --git a/DSTAR2YSF/Conf.cpp b/DSTAR2YSF/Conf.cpp new file mode 100644 index 0000000..41b5cb4 --- /dev/null +++ b/DSTAR2YSF/Conf.cpp @@ -0,0 +1,413 @@ +/* + * Copyright (C) 2015-2019 by Jonathan Naylor G4KLX + * Copyright (C) 2018,2019 by Andy Uribe CA6JAU + * + * 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 +#include + +const int BUFFER_SIZE = 500; + +enum SECTION { + SECTION_NONE, + SECTION_INFO, + SECTION_DSTAR_NETWORK, + SECTION_YSF_NETWORK, + SECTION_LOG +}; + +CConf::CConf(const std::string& file) : +m_file(file), +m_mycall(), +m_urcall(), +m_rptr1(), +m_rptr2(), +m_suffix(), +m_userTxt(), +m_dstarDstAddress(), +m_dstarDstPort(0U), +m_dstarLocalAddress(), +m_dstarLocalPort(0U), +m_daemon(false), +m_dstarNetworkDebug(false), +m_callsign(), +m_dstAddress(), +m_dstPort(0U), +m_localAddress(), +m_localPort(0U), +m_fcsFile(), +m_fichCallSign(2U), +m_fichCallMode(0U), +m_fichFrameTotal(6U), +m_fichMessageRoute(0U), +m_fichVOIP(0U), +m_fichDataType(2U), +m_fichSQLType(0U), +m_fichSQLCode(0U), +m_ysfDT1(), +m_ysfDT2(), +m_ysfRadioID("*****"), +m_ysfDebug(false), +m_logDisplayLevel(0U), +m_logFileLevel(0U), +m_logFilePath(), +m_logFileRoot() +{ +} + +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, "[Info]", 6U) == 0) + section = SECTION_INFO; + else if (::strncmp(buffer, "[DSTAR Network]", 13U) == 0) + section = SECTION_DSTAR_NETWORK; + else if (::strncmp(buffer, "[YSF Network]", 13U) == 0) + section = SECTION_YSF_NETWORK; + else if (::strncmp(buffer, "[Log]", 5U) == 0) + section = SECTION_LOG; + else + section = SECTION_NONE; + + continue; + } + + char* key = ::strtok(buffer, " \t=\r\n"); + if (key == NULL) + continue; + + char* value = ::strtok(NULL, "\r\n"); + if (value == NULL) + continue; + + // Remove quotes from the value + size_t len = ::strlen(value); + char *t; + if (len > 1U && *value == '"' && value[len - 1U] == '"') { + value[len - 1U] = '\0'; + value++; + } + + if (section == SECTION_INFO) { + if (::strcmp(key, "Mycall") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_mycall = value; + } + else if (::strcmp(key, "Urcall") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_urcall = value; + } + else if (::strcmp(key, "Rptr1") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_rptr1 = value; + } + else if (::strcmp(key, "Rptr2") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_rptr2 = value; + } + else if (::strcmp(key, "Suffix") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_suffix = value; + } + else if (::strcmp(key, "UserText") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_userTxt = value; + } + else if(::strcmp(key, "VocoderDevice") == 0) { + m_vocoderDevice = value; + } + } else if (section == SECTION_DSTAR_NETWORK) { + if (::strcmp(key, "DstAddress") == 0) + m_dstarDstAddress = value; + else if (::strcmp(key, "DstPort") == 0) + m_dstarDstPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "LocalAddress") == 0) + m_dstarLocalAddress = value; + else if (::strcmp(key, "LocalPort") == 0) + m_dstarLocalPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "Daemon") == 0) + m_daemon = ::atoi(value) == 1; + else if (::strcmp(key, "Debug") == 0) + m_dstarNetworkDebug = ::atoi(value) == 1; + } else if (section == SECTION_YSF_NETWORK) { + if (::strcmp(key, "Callsign") == 0) { + // Convert the callsign to upper case + for (unsigned int i = 0U; value[i] != 0; i++) + value[i] = ::toupper(value[i]); + m_callsign = value; + } else if (::strcmp(key, "GatewayAddress") == 0) + m_dstAddress = value; + else if (::strcmp(key, "GatewayPort") == 0) + m_dstPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "LocalAddress") == 0) + m_localAddress = value; + else if (::strcmp(key, "LocalPort") == 0) + m_localPort = (unsigned int)::atoi(value); + else if (::strcmp(key, "FCSRooms") == 0) + m_fcsFile = value; + else if (::strcmp(key, "RadioID") == 0) + m_ysfRadioID = value; + else if (::strcmp(key, "Debug") == 0) + m_ysfDebug = ::atoi(value) == 1; + else if (::strcmp(key, "FICHCallsign") == 0) + m_fichCallSign = ::atoi(value); + else if (::strcmp(key, "FICHCallMode") == 0) + m_fichCallMode = ::atoi(value); + else if (::strcmp(key, "FICHFrameTotal") == 0) + m_fichFrameTotal = ::atoi(value); + else if (::strcmp(key, "FICHMessageRoute") == 0) + m_fichMessageRoute = ::atoi(value); + else if (::strcmp(key, "FICHVOIP") == 0) + m_fichVOIP = ::atoi(value); + else if (::strcmp(key, "FICHDataType") == 0) + m_fichDataType = ::atoi(value); + else if (::strcmp(key, "FICHSQLType") == 0) + m_fichSQLType = ::atoi(value); + else if (::strcmp(key, "FICHSQLCode") == 0) + m_fichSQLCode = ::atoi(value); + else if (::strcmp(key, "DT1") == 0){ + while ((t = strtok_r(value, ",", &value)) != NULL) + m_ysfDT1.push_back(::atoi(t)); + } else if (::strcmp(key, "DT2") == 0){ + while ((t = strtok_r(value, ",", &value)) != NULL) + m_ysfDT2.push_back(::atoi(t)); + } + } else if (section == SECTION_LOG) { + if (::strcmp(key, "FilePath") == 0) + m_logFilePath = value; + else if (::strcmp(key, "FileRoot") == 0) + m_logFileRoot = value; + else if (::strcmp(key, "FileLevel") == 0) + m_logFileLevel = (unsigned int)::atoi(value); + else if (::strcmp(key, "DisplayLevel") == 0) + m_logDisplayLevel = (unsigned int)::atoi(value); + } + } + + ::fclose(fp); + + return true; +} + +std::string CConf::getMycall() const +{ + return m_mycall; +} + +std::string CConf::getUrcall() const +{ + return m_urcall; +} + +std::string CConf::getRptr1() const +{ + return m_rptr1; +} + +std::string CConf::getRptr2() const +{ + return m_rptr2; +} + +std::string CConf::getSuffix() const +{ + return m_suffix; +} + +std::string CConf::getUserTxt() const +{ + return m_userTxt; +} + +std::string CConf::getVocoderDevice() const +{ + return m_vocoderDevice; +} + +std::string CConf::getDSTARDstAddress() const +{ + return m_dstarDstAddress; +} + +unsigned int CConf::getDSTARDstPort() const +{ + return m_dstarDstPort; +} + +std::string CConf::getDSTARLocalAddress() const +{ + return m_dstarLocalAddress; +} + +unsigned int CConf::getDSTARLocalPort() const +{ + return m_dstarLocalPort; +} + +bool CConf::getDaemon() const +{ + return m_daemon; +} + +bool CConf::getDSTARNetworkDebug() const +{ + return m_dstarNetworkDebug; +} + +std::string CConf::getCallsign() const +{ + return m_callsign; +} + +std::string CConf::getDstAddress() const +{ + return m_dstAddress; +} + +unsigned int CConf::getDstPort() const +{ + return m_dstPort; +} + +std::string CConf::getLocalAddress() const +{ + return m_localAddress; +} + +unsigned int CConf::getLocalPort() const +{ + return m_localPort; +} + +std::string CConf::getFCSFile() const +{ + return m_fcsFile; +} + +unsigned char CConf::getFICHCallSign() const +{ + return m_fichCallSign; +} + +unsigned char CConf::getFICHCallMode() const +{ + return m_fichCallMode; +} + +unsigned char CConf::getFICHFrameTotal() const +{ + return m_fichFrameTotal; +} + +unsigned char CConf::getFICHMessageRoute() const +{ + return m_fichMessageRoute; +} + +unsigned char CConf::getFICHVOIP() const +{ + return m_fichVOIP; +} + +unsigned char CConf::getFICHDataType() const +{ + return m_fichDataType; +} + +unsigned char CConf::getFICHSQLType() const +{ + return m_fichSQLType; +} + +unsigned char CConf::getFICHSQLCode() const +{ + return m_fichSQLCode; +} + +std::vector CConf::getYsfDT1() +{ + return m_ysfDT1; +} + +std::vector CConf::getYsfDT2() +{ + return m_ysfDT2; +} + +std::string CConf::getYsfRadioID() +{ + return m_ysfRadioID; +} + +bool CConf::getYSFDebug() const +{ + return m_ysfDebug; +} + +unsigned int CConf::getLogDisplayLevel() const +{ + return m_logDisplayLevel; +} + +unsigned int CConf::getLogFileLevel() const +{ + return m_logFileLevel; +} + +std::string CConf::getLogFilePath() const +{ + return m_logFilePath; +} + +std::string CConf::getLogFileRoot() const +{ + return m_logFileRoot; +} diff --git a/DSTAR2YSF/Conf.h b/DSTAR2YSF/Conf.h new file mode 100644 index 0000000..11674f5 --- /dev/null +++ b/DSTAR2YSF/Conf.h @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2015-2019 by Jonathan Naylor G4KLX + * Copyright (C) 2018,2019 by Andy Uribe CA6JAU + * + * 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 +#include + +class CConf +{ +public: + CConf(const std::string& file); + ~CConf(); + + bool read(); + + // The Info section + std::string getMycall() const; + std::string getUrcall() const; + std::string getRptr1() const; + std::string getRptr2() const; + std::string getSuffix() const; + std::string getUserTxt() const; + std::string getVocoderDevice() const; + + // The DSTAR Network section + bool getDaemon() const; + std::string getDSTARDstAddress() const; + unsigned int getDSTARDstPort() const; + std::string getDSTARLocalAddress() const; + unsigned int getDSTARLocalPort() const; + std::string getDSTARTGListFile() const; + bool getDSTARNetworkDebug() const; + + // The YSF Network section + std::string getCallsign() const; + std::string getDstAddress() const; + unsigned int getDstPort() const; + std::string getLocalAddress() const; + unsigned int getLocalPort() const; + std::string getFCSFile() const; + unsigned char getFICHCallSign() const; + unsigned char getFICHCallMode() const; + unsigned char getFICHFrameTotal() const; + unsigned char getFICHMessageRoute() const; + unsigned char getFICHVOIP() const; + unsigned char getFICHDataType() const; + unsigned char getFICHSQLType() const; + unsigned char getFICHSQLCode() const; + std::vector getYsfDT1(); + std::vector getYsfDT2(); + std::string getYsfRadioID(); + bool getYSFDebug() const; + + // The Log section + unsigned int getLogDisplayLevel() const; + unsigned int getLogFileLevel() const; + std::string getLogFilePath() const; + std::string getLogFileRoot() const; + +private: + std::string m_file; + std::string m_mycall; + std::string m_urcall; + std::string m_rptr1; + std::string m_rptr2; + std::string m_suffix; + std::string m_userTxt; + std::string m_vocoderDevice; + std::string m_dstarDstAddress; + unsigned int m_dstarDstPort; + std::string m_dstarLocalAddress; + unsigned int m_dstarLocalPort; + bool m_daemon; + bool m_dstarNetworkDebug; + + std::string m_callsign; + std::string m_dstAddress; + unsigned int m_dstPort; + std::string m_localAddress; + unsigned int m_localPort; + std::string m_fcsFile; + unsigned char m_fichCallSign; + unsigned char m_fichCallMode; + unsigned char m_fichFrameTotal; + unsigned char m_fichMessageRoute; + unsigned char m_fichVOIP; + unsigned char m_fichDataType; + unsigned char m_fichSQLType; + unsigned char m_fichSQLCode; + std::vector m_ysfDT1; + std::vector m_ysfDT2; + std::string m_ysfRadioID; + bool m_ysfDebug; + + unsigned int m_logDisplayLevel; + unsigned int m_logFileLevel; + std::string m_logFilePath; + std::string m_logFileRoot; +}; + +#endif diff --git a/DSTAR2YSF/DSTAR2YSF b/DSTAR2YSF/DSTAR2YSF new file mode 100755 index 0000000000000000000000000000000000000000..03daf0d3d8a6552e7b57eedb894277ced9421e10 GIT binary patch literal 2386328 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∋I3t~=tOED8dHiXT5={D(NXtZ;KgE$0q{N;^ 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%0Ar#q$c26jY_T8*R;^0!)x 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�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

U3vXPCUK$>~YT@%2=PrGEu0FH0 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

D0c~{<5n*gSU9Z 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 z zBDKuuA7ffFn^{+nD`jtVT4opAdeE_ynL%Y*JzLU3vGYda@n3$*>imq^(DqK#a+_L~ zk1RbVa_;3@O_qMLqkh0WuldK9=bVW2ciY-5tVRCGR$=zH`rmF?Yn=a@YLWfBPFqm= zn`d9QxfT6AwYA=6`S1oEULUEDnAte7)Gh04 zEqk4tdLpo5&E=nLh^ezn&F4l&)HwS?gD`q!+!PN zySDv)&;Bv74ed*h-d6vh?qWu#o;eRQdJJtlbZb4&cA<-F@z0i7-fO<{_>$1d@#8Yh z*7mQ{IJ>&+(ZlO<4=WlBo3wFq z-7S_OQ`5hleyz;1?`n)6aCAqd?QJZB3&+liuv@o%#+utb9?Rz|tz3P3+n$)8WO=aW z+EM9MYo+#+`5!*KI#`Y(@n@Or$#PC0-%x-9A5^v312bAIFt9__lndgWIh?Y6DU`|{+a zVa<*#ZeG#R%jQ+7^ZMGBil}mFif_O3cBpFDx1?s7+K8nPy)boWJOsk5ppDi7Fyqiuzg3ogD$Ur|wZyyk#&U3WHk<}`Ef>xUPvd^4j- z%iz$@=1e@ad}ouM)3zF3@6)EYe55>oIpX%>)qTrsI2JQD%VWmXeS<1mj8Cm(2s|<4 z%FxkE4PJNb8fCYid^uYllrrwS$)AqDar(0gmHMo-oX~Z5vz%pZ*SFkwb87VG^=}_O zpXCsJ^6sy;+mp&UylOM>%Q>G9ejNDa*<>f(ug^}OnYgRj(JP;2^%_v!uAAcb&y`YcUxAxIs zeXW%2HsN0CXzwrA8osizW&Ez4Y`1XT)^EOWu^PQ9z%XfZYIu)<*0M5d_T77KyJJ_o z+4>XZ%Z=Fec!Y17S@P_L$~NDWzwNnUe^l1eX;tFNM0aT&@33swkG

IJbIR(D0h) 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 z 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≪&SjGbkn@k(DXpzh^O_(gun} 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%0D9~n;8AI>o|TSMc8MqW9fZPM?4!diJsdNBQrXRp zGi|UZQv>+s{~+U4vEOm-#>AGk4FGiVIp8rPDOJ4eI3E{yGW>S&c3(zDQUWt+1^$ua zEbZ>W9|rWbbHLBMieDUO@i0&3B=CRzgN%0-abbsFPnE04g7Iq%G949d(V17#G3*p# zwuwwH;K!dsCi?Jc2EI?&c?^z>$Sel_`g6$0r7(z0may|tmM60p_#@|#i9SG^dd7yG z+tzq8UjeT(&b}ToI1Idc7KE$x+~~>V0blCN_(&~Ar)w*~tmnf{v&jbD1IV#HTKXv( z$ePgg8BY6`!p?i%(!BuiE$0x4j$_v~Gazy#>|}ZuazEft`65wZXgKDQ^-N2K^SG6sHoRHxs50_SAdIfT~h0A!LuX0SOfDzuXh)=y#QOFYG)CpG){X!0Q*~x5x!QHO|=x*N;0$dJ=e-M)_^?z^@+XG%4}gdo_4BM)=VU z0=b=4NZ^g)oN3cM_L(u=(`BNwBF_10kcUjjgx3!; zUB)r=YsgNJ+!sF!?XOk?wJMq>}gIfLM56~eOX&w={cN5(W(kRQi6@8I$TnTT7g z2FP^4nT-|rw{gw_bf&;t1KRs+xC#kU$2%?XBq_)VK+W}$F^&E5I@FdD?;OD6g&;Qo zb+eC*X{;cd#5<)hw1RvbsMmeunT-{Ahj?ct+(&``8_?g+hO3YuFNk+`?(mT5**L%g zI%^tq8i2yF@y^|CJY*Z7`uND0#tL#pyz}%H4|y?A3w-36jTQK&c<0?~Jopws?>HN- zLV~;_-WfT;Lp}}EQ6Cx8v-QwO>ydb8N`;5~4^V&j$e6|o^1XOx-c%2nk%L`7(7C69 zz`u-lwiS8sPJo_&He7`Sc`DvH*4#r*1!|#>jA`t#ny4-8I{dwtb}&DBD^R1)mIq<#jdSA8Te%LC1GotoGQ=N6{^5`aH_kgv}3FGT0HuJa{4Jb_n% z@oGu~CbqLOT-p)anA==u9_*|L_Jz<;Uy#G>HRhn}?C

_|dRcJ}9a^2L7(=gyCU{ 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

6v?3 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⪚I{DFA{P~L*+%&vQDI>^(O)yJ>n1E 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 literal 0 HcmV?d00001 diff --git a/DSTAR2YSF/DSTAR2YSF.cpp b/DSTAR2YSF/DSTAR2YSF.cpp new file mode 100644 index 0000000..38f8fc0 --- /dev/null +++ b/DSTAR2YSF/DSTAR2YSF.cpp @@ -0,0 +1,648 @@ +/* +* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX +* Copyright (C) 2018,2019 by Andy Uribe CA6JAU +* Copyright (C) 2018 by Manuel Sanchez EA7EE +* +* 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 "DSTAR2YSF.h" + +#include +#include +#include +#include +#include +#include + +#define BUFSIZE 1024 + +#define DSTAR_FRAME_PER 15U +#define YSF_FRAME_PER 90U + +const unsigned char CONN_RESP[] = {0x5DU, 0x41U, 0x5FU, 0x26U}; +const char* DEFAULT_INI_FILE = "/etc/DSTAR2YSF.ini"; + +const char* HEADER1 = "This software is for use on amateur radio networks only,"; +const char* HEADER2 = "it is to be used for educational purposes only. Its use on"; +const char* HEADER3 = "commercial networks is strictly prohibited."; +const char* HEADER4 = "Copyright(C) 2018,2019 by CA6JAU, G4KLX and others"; + +#include +#include +#include +#include +#include +#include +#include + +int end = 0; + +void sig_handler(int signo) +{ + if (signo == SIGTERM) { + end = 1; + ::fprintf(stdout, "Received SIGTERM\n"); + } +} + +int main(int argc, char** argv) +{ + const char* iniFile = DEFAULT_INI_FILE; + if (argc > 1) { + for (int currentArg = 1; currentArg < argc; ++currentArg) { + std::string arg = argv[currentArg]; + if ((arg == "-v") || (arg == "--version")) { + ::fprintf(stdout, "DSTAR2YSF version %s\n", VERSION); + return 0; + } else if (arg.substr(0, 1) == "-") { + ::fprintf(stderr, "Usage: DSTAR2YSF [-v|--version] [filename]\n"); + return 1; + } else { + iniFile = argv[currentArg]; + } + } + } + + // Capture SIGTERM to finish gracelessly + if (signal(SIGTERM, sig_handler) == SIG_ERR) + ::fprintf(stdout, "Can't catch SIGTERM\n"); + + CDSTAR2YSF* gateway = new CDSTAR2YSF(std::string(iniFile)); + + int ret = gateway->run(); + + delete gateway; + + return ret; +} + +CDSTAR2YSF::CDSTAR2YSF(const std::string& configFile) : +m_conf(configFile), +m_conv("/dev/ttyUSB0") +{ + m_dstarFrame = new unsigned char[200U]; + m_ysfFrame = new unsigned char[200U]; + ::memset(m_dstarFrame, 0U, 200U); + ::memset(m_ysfFrame, 0U, 200U); +} + +CDSTAR2YSF::~CDSTAR2YSF() +{ + delete[] m_dstarFrame; +} + +int CDSTAR2YSF::run() +{ + bool ret = m_conf.read(); + if (!ret) { + ::fprintf(stderr, "DSTAR2YSF: cannot read the .ini file\n"); + return 1; + } + + setlocale(LC_ALL, "C"); + + unsigned int logDisplayLevel = m_conf.getLogDisplayLevel(); + + if(m_conf.getDaemon()) + logDisplayLevel = 0U; + + bool m_daemon = m_conf.getDaemon(); + if (m_daemon) { + // Create new process + pid_t pid = ::fork(); + if (pid == -1) { + ::fprintf(stderr, "Couldn't fork() , exiting\n"); + return -1; + } else if (pid != 0) + exit(EXIT_SUCCESS); + + // Create new session and process group + if (::setsid() == -1) { + ::fprintf(stderr, "Couldn't setsid(), exiting\n"); + return -1; + } + + // Set the working directory to the root directory + if (::chdir("/") == -1) { + ::fprintf(stderr, "Couldn't cd /, exiting\n"); + return -1; + } + + //If we are currently root... + if (getuid() == 0) { + struct passwd* user = ::getpwnam("mmdvm"); + if (user == NULL) { + ::fprintf(stderr, "Could not get the mmdvm user, exiting\n"); + return -1; + } + + uid_t mmdvm_uid = user->pw_uid; + gid_t mmdvm_gid = user->pw_gid; + + //Set user and group ID's to mmdvm:mmdvm + if (setgid(mmdvm_gid) != 0) { + ::fprintf(stderr, "Could not set mmdvm GID, exiting\n"); + return -1; + } + + if (setuid(mmdvm_uid) != 0) { + ::fprintf(stderr, "Could not set mmdvm UID, exiting\n"); + return -1; + } + + //Double check it worked (AKA Paranoia) + if (setuid(0) != -1) { + ::fprintf(stderr, "It's possible to regain root - something is wrong!, exiting\n"); + return -1; + } + } + } + + ret = ::LogInitialise(m_conf.getLogFilePath(), m_conf.getLogFileRoot(), m_conf.getLogFileLevel(), logDisplayLevel); + if (!ret) { + ::fprintf(stderr, "DSTAR2YSF: unable to open the log file\n"); + return 1; + } + + if (m_daemon) { + ::close(STDIN_FILENO); + ::close(STDOUT_FILENO); + ::close(STDERR_FILENO); + } + + LogInfo(HEADER1); + LogInfo(HEADER2); + LogInfo(HEADER3); + LogInfo(HEADER4); + + m_callsign = m_conf.getCallsign(); + std::string mycall = m_conf.getMycall(); + std::string urcall = m_conf.getUrcall(); + std::string rptr1 = m_conf.getRptr1(); + std::string rptr2 = m_conf.getRptr2(); + std::string suffix = m_conf.getSuffix(); + + char usertxt[20]; + ::memset(usertxt, 0x20, 20); + ::memcpy(usertxt, m_conf.getUserTxt().c_str(), (m_conf.getUserTxt().size() <= 20) ? m_conf.getUserTxt().size() : 20); + + std::string dstar_dstAddress = m_conf.getDSTARDstAddress(); + unsigned int dstar_dstPort = m_conf.getDSTARDstPort(); + std::string dstar_localAddress = m_conf.getDSTARLocalAddress(); + unsigned int dstar_localPort = m_conf.getDSTARLocalPort(); + bool dstar_debug = m_conf.getDSTARNetworkDebug(); + + m_dstarNetwork = new CDSTARNetwork(dstar_localAddress, dstar_localPort, dstar_dstAddress, dstar_dstPort, mycall, dstar_debug); + + ret = m_dstarNetwork->open(); + if (!ret) { + ::LogError("Cannot open the DSTAR network port"); + ::LogFinalise(); + return 1; + } + + in_addr dstAddress = CUDPSocket::lookup(m_conf.getDstAddress()); + unsigned int dstPort = m_conf.getDstPort(); + std::string localAddress = m_conf.getLocalAddress(); + unsigned int localPort = m_conf.getLocalPort(); + unsigned int ysfdebug = m_conf.getYSFDebug(); + + m_ysfNetwork = new CYSFNetwork(localAddress, localPort, m_callsign, ysfdebug); + m_ysfNetwork->setDestination(dstAddress, dstPort); + + ret = m_ysfNetwork->open(); + if (!ret) { + ::LogError("Cannot open the YSF network port"); + ::LogFinalise(); + return 1; + } + + CTimer pollTimer(1000U, 5U); + + CStopWatch stopWatch; + CStopWatch dstarWatch; + CStopWatch ysfWatch; + stopWatch.start(); + dstarWatch.start(); + ysfWatch.start(); + pollTimer.start(); + + unsigned char dstar_cnt = 0; + unsigned char ysf_cnt = 0; + + LogMessage("Starting DSTAR2YSF-%s", VERSION); + + for (; end == 0;) { + unsigned char buffer[2000U]; + unsigned char data[41U]; + int16_t pcm[160]; + memset(pcm, 0, sizeof(pcm)); + unsigned int ms = stopWatch.elapsed(); + + while (m_ysfNetwork->read(buffer) > 0U) { + CYSFFICH fich; + bool valid = fich.decode(buffer + 35U); + + if (valid) { + unsigned char fi = fich.getFI(); + unsigned char dt = fich.getDT(); + unsigned char fn = fich.getFN(); + unsigned char ft = fich.getFT(); + + if (::memcmp(buffer, "YSFD", 4U) == 0U) { + processWiresX(buffer + 35U, fi, dt, fn, ft); + + if (dt == YSF_DT_VD_MODE2) { + CYSFPayload ysfPayload; + + if (fi == YSF_FI_HEADER) { + if (ysfPayload.processHeaderData(buffer + 35U)) { + std::string ysfSrc = ysfPayload.getSource(); + std::string ysfDst = ysfPayload.getDest(); + LogMessage("Received YSF Header: Src: %s Dst: %s", ysfSrc.c_str(), ysfDst.c_str()); + m_conv.putYSFHeader(); + } + } else if (fi == YSF_FI_TERMINATOR) { + LogMessage("YSF received end of voice transmission"); + m_conv.putYSFEOT(); + } else if (fi == YSF_FI_COMMUNICATIONS) { + m_conv.putYSF(buffer + 35U); + } + } + } + } + } + if (dstarWatch.elapsed() > DSTAR_FRAME_PER) { + unsigned int dstarFrameType = m_conv.getDSTAR(m_dstarFrame); + + fprintf(stderr, "type:ms %d:%d\n", dstarFrameType, dstarWatch.elapsed()); + + if(dstarFrameType == TAG_HEADER) { + data[0] = 0; + data[1] = 0; + data[2] = 0; + + ::memcpy(data+3, rptr2.c_str(), rptr2.size()); + ::memset(data+3+rptr2.size(), 0x20, 8-rptr2.size()); + + ::memcpy(data+11, rptr1.c_str(), rptr1.size()); + ::memset(data+11+rptr1.size(), 0x20, 8-rptr1.size()); + + ::memcpy(data+19, urcall.c_str(), urcall.size()); + ::memset(data+19+urcall.size(), 0x20, 8-urcall.size()); + + ::memcpy(data+27, mycall.c_str(), mycall.size()); + ::memset(data+27+mycall.size(), 0x20, 8-mycall.size()); + + ::memcpy(data+35, suffix.c_str(), 4); + + data[39] = 0xea; + data[40] = 0x7e; + m_dstarNetwork->writeHeader(data, 41U); + //m_dstarNetwork->writeHeader(data, 41U); + dstar_cnt = 0U; + //dstarWatch.start(); + + } + else if(dstarFrameType == TAG_EOT) { + ::memcpy(data, m_dstarFrame, 9); + if(dstar_cnt % 0x15 == 0){ + data[9] = 0x55; + data[10] = 0x2d; + data[11] = 0x16; + } + else{ + data[9] = 0; + data[10] = 0; + data[11] = 0; + } + m_dstarNetwork->writeData(data, 12U, true); + //dstarWatch.start(); + } + else if(dstarFrameType == TAG_DATA) { + ::memcpy(data, m_dstarFrame, 9); + switch(dstar_cnt){ + case 0: + data[9] = 0x55; + data[10] = 0x2d; + data[11] = 0x16; + break; + case 1: + data[9] = 0x40 ^ 0x70; + data[10] = usertxt[0] ^ 0x4f; + data[11] = usertxt[1] ^ 0x93; + break; + case 2: + data[9] = usertxt[2] ^ 0x70; + data[10] = usertxt[3] ^ 0x4f; + data[11] = usertxt[4] ^ 0x93; + break; + case 3: + data[9] = 0x41 ^ 0x70; + data[10] = usertxt[5] ^ 0x4f; + data[11] = usertxt[6] ^ 0x93; + break; + case 4: + data[9] = usertxt[7] ^ 0x70; + data[10] = usertxt[8] ^ 0x4f; + data[11] = usertxt[9] ^ 0x93; + break; + case 5: + data[9] = 0x42 ^ 0x70; + data[10] = usertxt[10] ^ 0x4f; + data[11] = usertxt[11] ^ 0x93; + break; + case 6: + data[9] = usertxt[12] ^ 0x70; + data[10] = usertxt[13] ^ 0x4f; + data[11] = usertxt[14] ^ 0x93; + break; + case 7: + data[9] = 0x43 ^ 0x70; + data[10] = usertxt[15] ^ 0x4f; + data[11] = usertxt[16] ^ 0x93; + break; + case 8: + data[9] = usertxt[17] ^ 0x70; + data[10] = usertxt[18] ^ 0x4f; + data[11] = usertxt[19] ^ 0x93; + break; + default: + data[9] = 0x16; + data[10] = 0x29; + data[11] = 0xf5; + break; + } + + m_dstarNetwork->writeData(data, 12U, false); + //CUtils::dump(1U, "P25 Data", m_p25Frame, 11U); + (dstar_cnt >= 0x14) ? dstar_cnt = 0 : ++dstar_cnt; + //dstarWatch.start(); + } + dstarWatch.start(); + } + + if (m_dstarNetwork->readData(m_dstarFrame, 49U) > 0U) { + if(::memcmp("DSRP ", m_dstarFrame, 5) == 0){ + m_conv.putDSTARHeader(); + } + if(::memcmp("DSRP!", m_dstarFrame, 5) == 0){ + m_conv.putDSTAR(m_dstarFrame + 9); + } + //CUtils::dump(1U, "DSTAR Data", m_dstarFrame, 49U); + } + + if (ysfWatch.elapsed() > YSF_FRAME_PER) { + unsigned int ysfFrameType = m_conv.getYSF(m_ysfFrame + 35U); + + //fprintf(stderr, "type:ms %d:%d\n", ysfFrameType, ysfWatch.elapsed()); + + if(ysfFrameType == TAG_HEADER) { + ysf_cnt = 0U; + + ::memcpy(m_ysfFrame + 0U, "YSFD", 4U); + ::memcpy(m_ysfFrame + 4U, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + ::memcpy(m_ysfFrame + 14U, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + ::memcpy(m_ysfFrame + 24U, "ALL ", YSF_CALLSIGN_LENGTH); + m_ysfFrame[34U] = 0U; // Net frame counter + + ::memcpy(m_ysfFrame + 35U, YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES); + + // Set the FICH + CYSFFICH fich; + fich.setFI(YSF_FI_HEADER); + fich.setCS(m_conf.getFICHCallSign()); + fich.setCM(m_conf.getFICHCallMode()); + fich.setBN(0U); + fich.setBT(0U); + fich.setFN(0U); + fich.setFT(m_conf.getFICHFrameTotal()); + fich.setDev(0U); + fich.setMR(m_conf.getFICHMessageRoute()); + fich.setVoIP(m_conf.getFICHVOIP()); + fich.setDT(m_conf.getFICHDataType()); + fich.setSQL(m_conf.getFICHSQLType()); + fich.setSQ(m_conf.getFICHSQLCode()); + fich.encode(m_ysfFrame + 35U); + + unsigned char csd1[20U], csd2[20U]; + memset(csd1, '*', YSF_CALLSIGN_LENGTH); + memset(csd1, '*', YSF_CALLSIGN_LENGTH/2); + memcpy(csd1 + YSF_CALLSIGN_LENGTH/2, m_conf.getYsfRadioID().c_str(), YSF_CALLSIGN_LENGTH/2); + memcpy(csd1 + YSF_CALLSIGN_LENGTH, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + memset(csd2, ' ', YSF_CALLSIGN_LENGTH + YSF_CALLSIGN_LENGTH); + + CYSFPayload payload; + payload.writeHeader(m_ysfFrame + 35U, csd1, csd2); + + m_ysfNetwork->write(m_ysfFrame); + + ysf_cnt++; + //ysfWatch.start(); + } + else if (ysfFrameType == TAG_EOT) { + + ::memcpy(m_ysfFrame + 0U, "YSFD", 4U); + ::memcpy(m_ysfFrame + 4U, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + ::memcpy(m_ysfFrame + 14U, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + ::memcpy(m_ysfFrame + 24U, "ALL ", YSF_CALLSIGN_LENGTH); + m_ysfFrame[34U] = ysf_cnt; // Net frame counter + + ::memcpy(m_ysfFrame + 35U, YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES); + + // Set the FICH + CYSFFICH fich; + fich.setFI(YSF_FI_TERMINATOR); + fich.setCS(m_conf.getFICHCallSign()); + fich.setCM(m_conf.getFICHCallMode()); + fich.setBN(0U); + fich.setBT(0U); + fich.setFN(0U); + fich.setFT(m_conf.getFICHFrameTotal()); + fich.setDev(0U); + fich.setMR(m_conf.getFICHMessageRoute()); + fich.setVoIP(m_conf.getFICHVOIP()); + fich.setDT(m_conf.getFICHDataType()); + fich.setSQL(m_conf.getFICHSQLType()); + fich.setSQ(m_conf.getFICHSQLCode()); + fich.encode(m_ysfFrame + 35U); + + unsigned char csd1[20U], csd2[20U]; + memset(csd1, '*', YSF_CALLSIGN_LENGTH/2); + memcpy(csd1 + YSF_CALLSIGN_LENGTH/2, m_conf.getYsfRadioID().c_str(), YSF_CALLSIGN_LENGTH/2); + memcpy(csd1 + YSF_CALLSIGN_LENGTH, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + memset(csd2, ' ', YSF_CALLSIGN_LENGTH + YSF_CALLSIGN_LENGTH); + + CYSFPayload payload; + payload.writeHeader(m_ysfFrame + 35U, csd1, csd2); + + m_ysfNetwork->write(m_ysfFrame); + } + else if (ysfFrameType == TAG_DATA) { + + CYSFFICH fich; + CYSFPayload ysfPayload; + unsigned char dch[10U]; + + unsigned int fn = (ysf_cnt - 1U) % (m_conf.getFICHFrameTotal() + 1); + + ::memcpy(m_ysfFrame + 0U, "YSFD", 4U); + ::memcpy(m_ysfFrame + 4U, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + ::memcpy(m_ysfFrame + 14U, m_callsign.c_str(), YSF_CALLSIGN_LENGTH); + ::memcpy(m_ysfFrame + 24U, "ALL ", YSF_CALLSIGN_LENGTH); + + ::memcpy(m_ysfFrame + 35U, YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES); + + switch (fn) { + case 0: + memset(dch, '*', YSF_CALLSIGN_LENGTH/2); + memcpy(dch + YSF_CALLSIGN_LENGTH/2, m_conf.getYsfRadioID().c_str(), YSF_CALLSIGN_LENGTH/2); + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, dch); + break; + case 1: + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, (unsigned char*)m_callsign.c_str()); + break; + case 2: + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, (unsigned char*)m_callsign.c_str()); + break; + case 5: + memset(dch, ' ', YSF_CALLSIGN_LENGTH/2); + memcpy(dch + YSF_CALLSIGN_LENGTH/2, m_conf.getYsfRadioID().c_str(), YSF_CALLSIGN_LENGTH/2); + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, dch); // Rem3/4 + break; + case 6: { + unsigned char dt1[10U] = {0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}; + for (unsigned int i = 0U; i < m_conf.getYsfDT1().size() && i < 10U; i++) + dt1[i] = m_conf.getYsfDT1()[i]; + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, dt1); + } + break; + case 7: { + unsigned char dt2[10U] = {0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}; + for (unsigned int i = 0U; i < m_conf.getYsfDT2().size() && i < 10U; i++) + dt2[i] = m_conf.getYsfDT2()[i]; + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, dt2); + } + break; + default: + ysfPayload.writeVDMode2Data(m_ysfFrame + 35U, (const unsigned char*)" "); + } + + // Set the FICH + fich.setFI(YSF_FI_COMMUNICATIONS); + fich.setCS(m_conf.getFICHCallSign()); + fich.setCM(m_conf.getFICHCallMode()); + fich.setBN(0U); + fich.setBT(0U); + fich.setFN(fn); + fich.setFT(m_conf.getFICHFrameTotal()); + fich.setDev(0U); + fich.setMR(m_conf.getFICHMessageRoute()); + fich.setVoIP(m_conf.getFICHVOIP()); + fich.setDT(m_conf.getFICHDataType()); + fich.setSQL(m_conf.getFICHSQLType()); + fich.setSQ(m_conf.getFICHSQLCode()); + fich.encode(m_ysfFrame + 35U); + + // Net frame counter + m_ysfFrame[34U] = (ysf_cnt & 0x7FU) << 1; + + // Send data + m_ysfNetwork->write(m_ysfFrame); + + ysf_cnt++; + //ysfWatch.start(); + } + ysfWatch.start(); + } + + + stopWatch.start(); + m_ysfNetwork->clock(ms); + pollTimer.clock(ms); + + if (pollTimer.isRunning() && pollTimer.hasExpired()) { + //m_dstarNetwork->writePoll(); + pollTimer.start(); + } + + if (ms < 5U) + ::usleep(5 * 1000); + } + + m_dstarNetwork->close(); + + delete m_dstarNetwork; + + ::LogFinalise(); + + return 0; +} + +void CDSTAR2YSF::processWiresX(const unsigned char* data, unsigned char fi, unsigned char dt, unsigned char fn, unsigned char ft) +{ + assert(data != NULL); + unsigned char command[300U]; + + if (dt != YSF_DT_DATA_FR_MODE) + return; + + if (fi != YSF_FI_COMMUNICATIONS) + return; + + CYSFPayload payload; + + if (fn == 0U) + return; + + if (fn == 1U) { + bool valid = payload.readDataFRModeData2(data, command + 0U); + if (!valid) + return; + } else { + bool valid = payload.readDataFRModeData1(data, command + (fn - 2U) * 40U + 20U); + if (!valid) + return; + + valid = payload.readDataFRModeData2(data, command + (fn - 2U) * 40U + 40U); + if (!valid) + return; + } + + if (fn == ft) { + bool valid = false; + // Find the end marker + for (unsigned int i = (fn - 1U) * 40U + 20U; i > 0U; i--) { + if (command[i] == 0x03U) { + unsigned char crc = CCRC::addCRC(command, i + 1U); + if (crc == command[i + 1U]) + valid = true; + break; + } + } + + if (!valid) + return; + + if (::memcmp(command + 1U, CONN_RESP, 4U) == 0) { + LogMessage("Reflector connected OK"); + return; + } + } + + return; +} + diff --git a/DSTAR2YSF/DSTAR2YSF.h b/DSTAR2YSF/DSTAR2YSF.h new file mode 100644 index 0000000..ade81b6 --- /dev/null +++ b/DSTAR2YSF/DSTAR2YSF.h @@ -0,0 +1,61 @@ +/* +* Copyright (C) 2016 by Jonathan Naylor G4KLX +* Copyright (C) 2018 by Andy Uribe CA6JAU +* Copyright (C) 2018 by Manuel Sanchez EA7EE +* +* 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(DSTAR2YSF_H) +#define DSTAR2YSF_H + +#include "DSTARNetwork.h" +#include "ModeConv.h" +#include "UDPSocket.h" +#include "StopWatch.h" +#include "Version.h" +#include "YSFPayload.h" +#include "YSFNetwork.h" +#include "YSFFICH.h" +#include "Timer.h" +#include "Utils.h" +#include "Conf.h" +#include "Log.h" +#include "CRC.h" + +#include + +class CDSTAR2YSF +{ +public: + CDSTAR2YSF(const std::string& configFile); + ~CDSTAR2YSF(); + + int run(); + +private: + std::string m_callsign; + CConf m_conf; + CDSTARNetwork* m_dstarNetwork; + CYSFNetwork* m_ysfNetwork; + unsigned char* m_ysfFrame; + CModeConv m_conv; + unsigned char* m_dstarFrame; + unsigned int m_dstarFrames; + + void processWiresX(const unsigned char* data, unsigned char fi, unsigned char dt, unsigned char fn, unsigned char ft); +}; + +#endif diff --git a/DSTAR2YSF/DSTAR2YSF.ini b/DSTAR2YSF/DSTAR2YSF.ini new file mode 100644 index 0000000..7f83ad7 --- /dev/null +++ b/DSTAR2YSF/DSTAR2YSF.ini @@ -0,0 +1,43 @@ +[Info] +Mycall=AD8DS +Urcall=CQCQCQ +Rptr1=AD8DP A +Rptr2=W8DTW G +Suffix=DUDD + +[YSF Network] +Callsign=G9BF +GatewayAddress=127.0.0.1 +GatewayPort=4200 +LocalAddress=127.0.0.1 +LocalPort=3200 +FCSRooms=FCSRooms.txt +# RadioID=***** +# FICHCallsign=2 +# FICHCallMode=0 +# FICHFrameTotal=6 +# FICHMessageRoute=0 +# FICHVOIP=0 +# FICHDataType=2 +# FICHSQLType=0 +# FICHSQLCode=0 +DT1=1,34,97,95,43,3,17,0,0,0 +DT2=0,0,0,0,108,32,28,32,3,8 +Daemon=0 +Debug=0 + +[DSTAR Network] +DstAddress=127.0.0.1 +DstPort=20011 +LocalAddress=127.0.0.1 +LocalPort=20009 +Daemon=0 +Debug=1 + +[Log] +# Logging levels, 0=No logging +DisplayLevel=1 +FileLevel=1 +FilePath=. +FileRoot=DSTAR2YSF + diff --git a/DSTAR2YSF/DSTARNetwork.cpp b/DSTAR2YSF/DSTARNetwork.cpp new file mode 100644 index 0000000..80afa8c --- /dev/null +++ b/DSTAR2YSF/DSTARNetwork.cpp @@ -0,0 +1,168 @@ +/* + * Copyright (C) 2009-2014,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 "DSTARNetwork.h" +#include "Utils.h" +#include "Log.h" + +#include +#include +#include + +CDSTARNetwork::CDSTARNetwork(const std::string& localAddress, unsigned int localPort, const std::string& gatewayAddress, unsigned int gatewayPort, const std::string& callsign, bool debug) : +m_callsign(callsign), +m_address(), +m_port(gatewayPort), +m_socket(localAddress, localPort), +m_debug(debug) +{ + m_callsign.resize(10U, ' '); + m_address = CUDPSocket::lookup(gatewayAddress); +} + +CDSTARNetwork::~CDSTARNetwork() +{ +} + +bool CDSTARNetwork::open() +{ + LogInfo("Opening DSTAR network connection"); + + return m_socket.open(); +} + +bool CDSTARNetwork::writeHeader(const unsigned char* header, unsigned int length) +{ + assert(header != NULL); + + unsigned char buffer[50U]; + + buffer[0] = 'D'; + buffer[1] = 'S'; + buffer[2] = 'R'; + buffer[3] = 'P'; + buffer[4] = 0x20U; + + // Create a random id for this transmission + //std::uniform_int_distribution dist(0x0001, 0xfffe); + //m_outId = 0x1234;//dist(m_random); + m_outId = rand() % 65536; + + buffer[5] = m_outId / 256U; // Unique session id + buffer[6] = m_outId % 256U; + + buffer[7] = 0U; + + ::memcpy(buffer + 8U, header, length); + + m_outSeq = 0U; + + + + for (unsigned int i = 0U; i < 2U; i++) { + bool ret = m_socket.write(buffer, 49U, m_address, m_port); + if (m_debug) + CUtils::dump(1U, "D-Star Network Header Sent", buffer, 49U); + + if (!ret) + return false; + } + + return true; +} + +bool CDSTARNetwork::writeData(const unsigned char* data, unsigned int length, bool end) +{ + assert(data != NULL); + + unsigned char buffer[30U]; + + buffer[0] = 'D'; + buffer[1] = 'S'; + buffer[2] = 'R'; + buffer[3] = 'P'; + buffer[4] = 0x21U; + buffer[5] = m_outId / 256U; // Unique session id + buffer[6] = m_outId % 256U; + + // If this is a data sync, reset the sequence to zero + if (data[9] == 0x55 && data[10] == 0x2D && data[11] == 0x16) + m_outSeq = 0U; + + buffer[7] = m_outSeq; + if (end) + buffer[7] |= 0x40U; // End of data marker + + buffer[8] = 0; + + m_outSeq++; + if (m_outSeq > 0x14U) + m_outSeq = 0U; + + ::memcpy(buffer + 9U, data, length); + + if (m_debug) + CUtils::dump(1U, "D-Star Network Data Sent", buffer, length + 9U); + + return m_socket.write(buffer, length + 9U, m_address, m_port); +} + +bool CDSTARNetwork::writePoll() +{ + unsigned char data[15U]; + + data[0U] = 0xF0U; + + for (unsigned int i = 0U; i < 10U; i++) + data[i + 1U] = m_callsign.at(i); + + if (m_debug) + CUtils::dump(1U, "DSTAR Network Poll Sent", data, 11U); + + return m_socket.write(data, 11U, m_address, m_port); +} + +unsigned int CDSTARNetwork::readData(unsigned char* data, unsigned int length) +{ + assert(data != NULL); + assert(length > 0U); + + in_addr address; + unsigned int port; + int len = m_socket.read(data, length, address, port); + if (len <= 0) + return 0U; + + // Check if the data is for us + if (m_address.s_addr != address.s_addr || port != m_port) { + LogMessage("DSTAR packet received from an invalid source, %08X != %08X and/or %u != %u", m_address.s_addr, address.s_addr, m_port, port); + return 0U; + } + + if (m_debug) + CUtils::dump(1U, "DSTAR Network Data Received", data, len); + + return len; +} + +void CDSTARNetwork::close() +{ + m_socket.close(); + + LogInfo("Closing DSTAR network connection"); +} diff --git a/DSTAR2YSF/DSTARNetwork.h b/DSTAR2YSF/DSTARNetwork.h new file mode 100644 index 0000000..f2f29d0 --- /dev/null +++ b/DSTAR2YSF/DSTARNetwork.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009-2014,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 DSTARNetwork_H +#define DSTARNetwork_H + +#include "UDPSocket.h" + +#include +#include + +class CDSTARNetwork { +public: + CDSTARNetwork(const std::string& localAddress, unsigned int localPort, const std::string& gatewayAddress, unsigned int gatewayPort, const std::string& callsign, bool debug); + ~CDSTARNetwork(); + + bool open(); + bool writeHeader(const unsigned char* data, unsigned int length); + bool writeData(const unsigned char* data, unsigned int length, bool end); + unsigned int readData(unsigned char* data, unsigned int length); + bool writePoll(); + void close(); + +private: + std::string m_callsign; + in_addr m_address; + unsigned int m_port; + CUDPSocket m_socket; + bool m_debug; + uint16_t m_outId; + uint8_t m_outSeq; +}; + +#endif diff --git a/DSTAR2YSF/Golay24128.cpp b/DSTAR2YSF/Golay24128.cpp new file mode 100644 index 0000000..417da00 --- /dev/null +++ b/DSTAR2YSF/Golay24128.cpp @@ -0,0 +1,1108 @@ +/* + * Copyright (C) 2010,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2002 by Robert H. Morelos-Zaragoza. All rights reserved. + */ + +#include "Golay24128.h" + +#include +#include + +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); +} + +unsigned int CGolay24128::decode24128(unsigned char* bytes) +{ + assert(bytes != NULL); + + unsigned int code = bytes[0U]; + code <<= 8; + code |= bytes[1U]; + code <<= 8; + code |= bytes[2U]; + + return decode23127(code >> 1); +} diff --git a/DSTAR2YSF/Golay24128.h b/DSTAR2YSF/Golay24128.h new file mode 100644 index 0000000..1ac7852 --- /dev/null +++ b/DSTAR2YSF/Golay24128.h @@ -0,0 +1,32 @@ +/* + * 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); + static unsigned int decode24128(unsigned char* bytes); +}; + +#endif diff --git a/DSTAR2YSF/Log.cpp b/DSTAR2YSF/Log.cpp new file mode 100644 index 0000000..fc37ebf --- /dev/null +++ b/DSTAR2YSF/Log.cpp @@ -0,0 +1,136 @@ +/* + * 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 "Log.h" + +#if defined(_WIN32) || defined(_WIN64) +#include +#else +#include +#endif + +#include +#include +#include +#include +#include +#include + +static unsigned int m_fileLevel = 2U; +static std::string m_filePath; +static std::string m_fileRoot; + +static FILE* m_fpLog = NULL; + +static unsigned int m_displayLevel = 2U; + +static struct tm m_tm; + +static char LEVELS[] = " DMIWEF"; + +static bool LogOpen() +{ + if (m_fileLevel == 0U) + return true; + + 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[100U]; +#if defined(_WIN32) || defined(_WIN64) + ::sprintf(filename, "%s\\%s-%04d-%02d-%02d.log", m_filePath.c_str(), m_fileRoot.c_str(), tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday); +#else + ::sprintf(filename, "%s/%s-%04d-%02d-%02d.log", m_filePath.c_str(), m_fileRoot.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& filePath, const std::string& fileRoot, unsigned int fileLevel, unsigned int displayLevel) +{ + m_filePath = filePath; + m_fileRoot = fileRoot; + m_fileLevel = fileLevel; + m_displayLevel = displayLevel; + return ::LogOpen(); +} + +void LogFinalise() +{ + if (m_fpLog != NULL) + ::fclose(m_fpLog); +} + +void Log(unsigned int level, const char* fmt, ...) +{ + assert(fmt != NULL); + + char buffer[300U]; +#if defined(_WIN32) || defined(_WIN64) + SYSTEMTIME st; + ::GetSystemTime(&st); + + ::sprintf(buffer, "%c: %04u-%02u-%02u %02u:%02u:%02u.%03u ", LEVELS[level], st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds); +#else + struct timeval now; + ::gettimeofday(&now, NULL); + + struct tm* tm = ::gmtime(&now.tv_sec); + + ::sprintf(buffer, "%c: %04d-%02d-%02d %02d:%02d:%02d.%03lu ", LEVELS[level], tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, now.tv_usec / 1000U); +#endif + + va_list vl; + va_start(vl, fmt); + + ::vsprintf(buffer + ::strlen(buffer), fmt, vl); + + va_end(vl); + + if (level >= m_fileLevel && m_fileLevel != 0U) { + bool ret = ::LogOpen(); + if (!ret) + return; + + ::fprintf(m_fpLog, "%s\n", buffer); + ::fflush(m_fpLog); + } + + if (level >= m_displayLevel && m_displayLevel != 0U) { + ::fprintf(stdout, "%s\n", buffer); + ::fflush(stdout); + } + + if (level == 6U) { // Fatal + ::fclose(m_fpLog); + exit(1); + } +} diff --git a/DSTAR2YSF/Log.h b/DSTAR2YSF/Log.h new file mode 100644 index 0000000..d671ef9 --- /dev/null +++ b/DSTAR2YSF/Log.h @@ -0,0 +1,36 @@ +/* + * 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(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& filePath, const std::string& fileRoot, unsigned int fileLevel, unsigned int displayLevel); +extern void LogFinalise(); + +#endif diff --git a/DSTAR2YSF/Makefile b/DSTAR2YSF/Makefile new file mode 100644 index 0000000..7aeda97 --- /dev/null +++ b/DSTAR2YSF/Makefile @@ -0,0 +1,21 @@ +CC ?= gcc +CXX ?= g++ +CFLAGS ?= -g -O3 -Wall -std=c++0x -pthread +LIBS = -lm -lmd380_vocoder +LDFLAGS ?= -g + +OBJECTS = Conf.o CRC.o Golay24128.o Log.o ModeConv.o DSTARNetwork.o SerialController.o \ + StopWatch.o Timer.o UDPSocket.o Utils.o YSFConvolution.o YSFFICH.o YSFNetwork.o \ + YSFPayload.o DSTAR2YSF.o + +all: DSTAR2YSF + +DSTAR2YSF: $(OBJECTS) + $(CXX) $(OBJECTS) $(CFLAGS) $(LIBS) -o DSTAR2YSF -Xlinker --section-start=.firmware=0x0800C000 -Xlinker --section-start=.sram=0x20000000 + +%.o: %.cpp + $(CXX) $(CFLAGS) -c -o $@ $< + +clean: + $(RM) DSTAR2YSF *.o *.d *.bak *~ + diff --git a/DSTAR2YSF/ModeConv.cpp b/DSTAR2YSF/ModeConv.cpp new file mode 100644 index 0000000..fea8abe --- /dev/null +++ b/DSTAR2YSF/ModeConv.cpp @@ -0,0 +1,524 @@ +/* + * Copyright (C) 2010,2014,2016 and 2018 by Jonathan Naylor G4KLX + * Copyright (C) 2016 Mathias Weyland, HB9FRV + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 "ModeConv.h" +#include "Utils.h" +#include "Log.h" +#include +#include +#include +#include +#include + +const unsigned int INTERLEAVE_TABLE_26_4[] = { + 0U, 4U, 8U, 12U, 16U, 20U, 24U, 28U, 32U, 36U, 40U, 44U, 48U, 52U, 56U, 60U, 64U, 68U, 72U, 76U, 80U, 84U, 88U, 92U, 96U, 100U, + 1U, 5U, 9U, 13U, 17U, 21U, 25U, 29U, 33U, 37U, 41U, 45U, 49U, 53U, 57U, 61U, 65U, 69U, 73U, 77U, 81U, 85U, 89U, 93U, 97U, 101U, + 2U, 6U, 10U, 14U, 18U, 22U, 26U, 30U, 34U, 38U, 42U, 46U, 50U, 54U, 58U, 62U, 66U, 70U, 74U, 78U, 82U, 86U, 90U, 94U, 98U, 102U, + 3U, 7U, 11U, 15U, 19U, 23U, 27U, 31U, 35U, 39U, 43U, 47U, 51U, 55U, 59U, 63U, 67U, 71U, 75U, 79U, 83U, 87U, 91U, 95U, 99U, 103U}; + +const unsigned char WHITENING_DATA[] = {0x93U, 0xD7U, 0x51U, 0x21U, 0x9CU, 0x2FU, 0x6CU, 0xD0U, 0xEFU, 0x0FU, + 0xF8U, 0x3DU, 0xF1U, 0x73U, 0x20U, 0x94U, 0xEDU, 0x1EU, 0x7CU, 0xD8U}; + +const uint8_t BIT_MASK_TABLE[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U }; +#define WRITE_BIT(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7]) +#define READ_BIT(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) + +std::mutex m; + +CModeConv::CModeConv(std::string device) : +m_dstarN(0U), +m_ysfN(0U), +m_DSTAR(5000U, "YSF2DSTAR"), +m_YSF(5000U, "DSTAR2YSF") +{ + uint8_t buf[512]; + ::memset(buf, 0, sizeof(buf)); + const uint8_t AMBE2000_2400_1200[17] = {0x61, 0x00, 0x0d, 0x00, 0x0a, 0x01U, 0x30U, 0x07U, 0x63U, 0x40U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x48U}; + fprintf(stderr, "Creating vocoder on %s\n", device.c_str()); + vocoder = new CSerialController(device, SERIAL_460800); + fprintf(stderr, "Opening vocoder on %s\n", device.c_str()); + vocoder->open(); + fprintf(stderr, "Opened vocoder on %s\n", device.c_str()); + int lw = vocoder->write(AMBE2000_2400_1200, sizeof(AMBE2000_2400_1200)); + int lr = vocoder->read(buf, 6); + + fprintf(stderr, "AMBEHW:%d:%d: ", lw, lr); + for(int i = 0; i < lr; ++i){ + fprintf(stderr, "%02x ", buf[i]); + } + fprintf(stderr, "\n"); + fflush(stderr); + vocoder_thread = new std::thread(&CModeConv::vocoder_thread_fn, this); +} + +CModeConv::~CModeConv() +{ +} + +void CModeConv::vocoder_thread_fn() +{ + uint8_t dvsi_rx[512]; + uint8_t ambe[9]; + uint8_t vch[13]; + int16_t pcm[160U]; + uint8_t pcm_bytes[326U]; + int lr; + + const char dvsi_pcm_header[] = {0x61, 0x01, 0x42, 0x02, 0x00, 0xa0}; + const char dvsi_pkt_header[] = {0x61, 0x00, 0x0b, 0x01, 0x01, 0x48}; + std::deque d; + d.clear(); + ::memset(dvsi_rx, 0, 512); + //::memset(pcm, 0, sizeof(pcm)); + fprintf(stderr, "CModeConv::vocoder_thread_fn() started queue size == %d\n", d.max_size()); + while(1){ + lr = vocoder->read(dvsi_rx, sizeof(dvsi_rx)); + + //fprintf(stderr, "AMBEHW:%d: ", lr); + for(int i = 0; i < lr; ++i){ + d.push_back(dvsi_rx[i]); + //fprintf(stderr, "%02x ", dvsi_rx[i]); + } + //fprintf(stderr, "\n"); + //fflush(stderr); + /* + fprintf(stderr, "QUEUE %d: ", d.size()); + for(std::deque::iterator i = d.begin(); i < d.end(); ++i){ + fprintf(stderr, "%02x ", *i); + } + fprintf(stderr, "\n"); + fflush(stderr); + */ + if((::memcmp(&(*(d.begin())), dvsi_pcm_header, 6) == 0) && d.size() > 325){ + d.erase(d.begin(), d.begin() + 6); + + std::deque::iterator p_rx = d.begin(); + for(int i = 0; i < 160; ++i){ + pcm[i] = ((p_rx[(i*2)] << 8) & 0xff00) | (p_rx[(i*2)+1] & 0xff); + } + encodeYSF(pcm, vch); + m_YSF.addData(&TAG_DATA, 1U); + m_YSF.addData(vch, 13U); + m_ysfN += 1U; + d.erase(d.begin(), d.begin() + 320); + } + + if(d.size() > 14){ + int j = 0; + for(std::deque::iterator i = d.begin()+6; i < d.begin()+15; ++i){ + ambe[j++] = *i; + } + try { + //m.lock(); + m_DSTAR.addData(&TAG_DATA, 1U); + m_DSTAR.addData(ambe, 9U); + m_dstarN += 1; + //m.unlock(); + } + catch(std::logic_error&){ + fprintf(stderr, "Exception\n"); + } + //m_mutex.unlock(); + d.erase(d.begin(), d.begin() + 15U); + //} + //else{ + // fprintf(stderr, "read thread try_lock() failed\n"); + //} + } + /* + if(m_dvsiEncode){ + fprintf(stderr, "CModeConv::vocoder_thread_fn() encode\n"); + lr = vocoder->read(dvsi_rx, sizeof(dvsi_rx)); + //fprintf(stderr, "CModeConv::vocoder_thread_fn() encoding lr == %d\n", lr); + //for(int i = 0; i < lr; ++i){ + // d.push(dvsi_rx[i]); + //} + if(lr != 15){ + fprintf(stderr, "vocoder returned %d\n", lr); + //continue; + } + //if(d.size() > 14){ + //d.pop(); + //d.pop(); + //d.pop(); + //d.pop(); + //d.pop(); + //d.pop(); + //for(int i = 0; i < 9; ++i){ + // ambe[i] = d.front(); + // d.pop(); + //} + //::memcpy(pcm, pcm_bytes, 320); + m_DSTAR.addData(&TAG_DATA, 1U); + //m_DSTAR.addData(ambe, 9U); + m_DSTAR.addData(dvsi_rx+6, 9U); + m_dstarN += 1; + //} + } + else{ + fprintf(stderr, "CModeConv::vocoder_thread_fn() decode\n"); + lr = vocoder->read(pcm_bytes, sizeof(pcm_bytes)); + fprintf(stderr, "CModeConv::vocoder_thread_fn() decoding lr == %d\n", lr); + //for(int i = 0; i < lr; ++i){ + // pcm_q.push(pcm_bytes[i]); + //} + if(lr != 326){ + fprintf(stderr, "vocoder returned %d\n", lr); + continue; + } + //if(pcm_q.size() > 325){ + uint8_t *p_rx = pcm_bytes + 6; + for(int i = 0; i < 160; ++i){ + pcm[i] = ((p_rx[(i*2)] << 8) & 0xff00) | (p_rx[(i*2)+1] & 0xff); + } + + encodeYSF(pcm, vch); + m_YSF.addData(&TAG_DATA, 1U); + m_YSF.addData(vch, 13U); + m_ysfN += 1U; + //} + } + + fprintf(stderr, "AMBEHW %d: ", lr); + for(int i = 0; i < lr; ++i){ + fprintf(stderr, "%02x ", pcm_bytes[i]); + } + fprintf(stderr, "\n"); + fflush(stderr); + */ + } +} + +void CModeConv::encodeYSF(int16_t *pcm, uint8_t *vch) +{ + static const uint8_t scramble_code[180] = { + 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, + 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, + 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, + 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, + 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, + 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, + 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, + 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 + }; + unsigned char ambe49[49]; + unsigned char ambe[7]; + uint8_t buf[104]; + uint8_t result[104]; + + memset(vch, 0, 13); + memset(ambe, 0, 7); + + md380_encode(ambe, pcm); + + for(int i = 0; i < 6; ++i){ + for(int j = 0; j < 8; j++){ + ambe49[j+(8*i)] = (1 & (ambe[i] >> (7 - j))); + } + } + ambe49[48] = (1 & (ambe[6] >> 7)); + + for (int i=0; i<27; i++) { + buf[0+i*3] = ambe49[i]; + buf[1+i*3] = ambe49[i]; + buf[2+i*3] = ambe49[i]; + } + memcpy(buf+81, ambe49+27, 22); + buf[103] = 0; + for (int i=0; i<104; i++) { + buf[i] = buf[i] ^ scramble_code[i]; + } + + int x=4; + int y=26; + for (int i=0; i= 1U) { + try { + //m.lock(); + m_DSTAR.getData(tag, 1U); + m_DSTAR.getData(data, 9U); + m_dstarN -= 1U; + //m.unlock(); + } + catch(std::logic_error&){ + fprintf(stderr, "Exception\n"); + } + return tag[0U]; + } + else + return TAG_NODATA; +} + +void CModeConv::putYSFHeader() +{ + uint8_t ambe[9U]; + ::memset(ambe, 0, 9); + m_DSTAR.addData(&TAG_HEADER, 1U); + m_DSTAR.addData(ambe, 9U); + m_dstarN += 1U; +} + +void CModeConv::putYSFEOT() +{ + uint8_t ambe[9U]; + ::memset(ambe, 0, 9); + m_DSTAR.addData(&TAG_EOT, 1U); + m_DSTAR.addData(ambe, 9U); + m_dstarN += 1U; +} + +void CModeConv::putYSF(unsigned char* data) +{ + unsigned char v_tmp[7U]; + uint8_t ambe[9U]; + int16_t pcm[160]; + + assert(data != NULL); + + ::memset(v_tmp, 0, 7U); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned int offset = 40U; // DCH(0) + + // We have a total of 5 VCH sections, iterate through each + for (unsigned int j = 0U; j < 5U; j++, offset += 144U) { + + unsigned char vch[13U]; + unsigned int dat_a = 0U; + unsigned int dat_b = 0U; + unsigned int dat_c = 0U; + + // Deinterleave + for (unsigned int i = 0U; i < 104U; i++) { + unsigned int n = INTERLEAVE_TABLE_26_4[i]; + bool s = READ_BIT(data, offset + n); + WRITE_BIT(vch, i, s); + } + + // "Un-whiten" (descramble) + for (unsigned int i = 0U; i < 13U; i++) + vch[i] ^= WHITENING_DATA[i]; + + for (unsigned int i = 0U; i < 12U; i++) { + dat_a <<= 1U; + if (READ_BIT(vch, 3U*i + 1U)) + dat_a |= 0x01U;; + } + + for (unsigned int i = 0U; i < 12U; i++) { + dat_b <<= 1U; + if (READ_BIT(vch, 3U*(i + 12U) + 1U)) + dat_b |= 0x01U;; + } + + for (unsigned int i = 0U; i < 3U; i++) { + dat_c <<= 1U; + if (READ_BIT(vch, 3U*(i + 24U) + 1U)) + dat_c |= 0x01U;; + } + + for (unsigned int i = 0U; i < 22U; i++) { + dat_c <<= 1U; + if (READ_BIT(vch, i + 81U)) + dat_c |= 0x01U;; + } + + for (unsigned int i = 0U; i < 12U; i++) { + bool s1 = (dat_a << (i + 20U)) & 0x80000000; + bool s2 = (dat_b << (i + 20U)) & 0x80000000; + WRITE_BIT(v_tmp, i, s1); + WRITE_BIT(v_tmp, i + 12U, s2); + } + + for (unsigned int i = 0U; i < 25U; i++) { + bool s = (dat_c << (i + 7U)) & 0x80000000; + WRITE_BIT(v_tmp, i + 24U, s); + } + md380_decode(v_tmp, pcm); + encode_2400(pcm, ambe); + //m_DSTAR.addData(&TAG_DATA, 1U); + //m_DSTAR.addData(ambe, 9U); + //m_dstarN += 1; + } +} + +unsigned int CModeConv::getYSF(unsigned char* data) +{ + unsigned char tag[1U]; + + tag[0U] = TAG_NODATA; + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + if (m_ysfN >= 1U) { + m_YSF.peek(tag, 1U); + + if (tag[0U] != TAG_DATA) { + m_YSF.getData(tag, 1U); + m_YSF.getData(data, 13U); + m_ysfN -= 1U; + return tag[0U]; + } + } + + if (m_ysfN >= 5U) { + data += 5U; + m_YSF.getData(tag, 1U); + m_YSF.getData(data, 13U); + m_ysfN -= 1U; + + data += 18U; + m_YSF.getData(tag, 1U); + m_YSF.getData(data, 13U); + m_ysfN -= 1U; + + data += 18U; + m_YSF.getData(tag, 1U); + m_YSF.getData(data, 13U); + m_ysfN -= 1U; + + data += 18U; + m_YSF.getData(tag, 1U); + m_YSF.getData(data, 13U); + m_ysfN -= 1U; + + data += 18U; + m_YSF.getData(tag, 1U); + m_YSF.getData(data, 13U); + m_ysfN -= 1U; + + return TAG_DATA; + } + else + return TAG_NODATA; +} + +void CModeConv::decode_2400(int16_t *pcm, uint8_t *ambe) +{ + uint8_t dvsi_tx[15] = {0x61, 0x00, 0x0b, 0x01, 0x01, 0x48}; + uint8_t dvsi_rx[326]; + + ::memcpy(dvsi_tx + 6, ambe, 9); + m_dvsiEncode = false; + int lw = vocoder->write(dvsi_tx, 15); + /* + int lr = vocoder->read(dvsi_rx, sizeof(dvsi_rx)); + + if(lr != 326){ + fprintf(stderr, "vocoder returned %d:%d\n", lr, lw); + return; + } + + uint8_t *p_rx = dvsi_rx + 6; + for(int i = 0; i < 160; ++i){ + pcm[i] = ((p_rx[(i*2)] << 8) & 0xff00) | (p_rx[(i*2)+1] & 0xff); + } + //::memcpy(pcm, dvsi_rx + 6, 320); + fprintf(stderr, "AMBEHW:%d:%d: ", lw, lr); + for(int i = 0; i < lr; ++i){ + fprintf(stderr, "%02x ", dvsi_rx[i]); + } + fprintf(stderr, "\n"); + fflush(stderr); + */ +} + +void CModeConv::encode_2400(int16_t *pcm, uint8_t *ambe) +{ + uint8_t dvsi_tx[326] = {0x61, 0x01, 0x42, 0x02, 0x00, 0xa0}; + uint8_t dvsi_rx[15]; + + uint8_t *p_tx = dvsi_tx + 6; + for(int i = 0; i < 160; ++i){ + p_tx[(i*2)+1] = pcm[i] & 0xff; + p_tx[(i*2)] = pcm[i] >> 8; + } + + //::memcpy(dvsi_tx + 6, pcm, 320); + m_dvsiEncode = true; + int lw = vocoder->write(dvsi_tx, sizeof(dvsi_tx)); + + //int lr = vocoder->read(dvsi_rx, sizeof(dvsi_rx)); + + //::memcpy(ambe, dvsi_rx + 6, 9); + /* + fprintf(stderr, "PCM:%d: ", lw); + for(int i = 0; i < lw; ++i){ + fprintf(stderr, "%02x ", dvsi_tx[i]); + } + fprintf(stderr, "\n"); + fflush(stderr); + */ +} diff --git a/DSTAR2YSF/ModeConv.h b/DSTAR2YSF/ModeConv.h new file mode 100644 index 0000000..0d40c42 --- /dev/null +++ b/DSTAR2YSF/ModeConv.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2010,2014,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 "YSFDefines.h" +#include "RingBuffer.h" +#include + + +const unsigned char TAG_HEADER = 0x00U; +const unsigned char TAG_DATA = 0x01U; +const unsigned char TAG_LOST = 0x02U; +const unsigned char TAG_EOT = 0x03U; +const unsigned char TAG_NODATA = 0x04U; + +#if !defined(MODECONV_H) +#define MODECONV_H + +class CModeConv { +public: + CModeConv(std::string device = "/dev/null"); + ~CModeConv(); + + void putDSTAR(unsigned char* bytes); + void putDSTARHeader(); + void putDSTAREOT(); + unsigned int getDSTAR(unsigned char* bytes); + + void putYSF(unsigned char* bytes); + void putYSFHeader(); + void putYSFEOT(); + + unsigned int getYSF(unsigned char* bytes); + +private: + void encodeYSF(int16_t *pcm, uint8_t *vch); + void decode_2400(int16_t *, uint8_t *); + void encode_2400(int16_t *, uint8_t *); + void vocoder_thread_fn(); + + unsigned int m_dstarN; + unsigned int m_ysfN; + CSerialController *vocoder; + CRingBuffer m_DSTAR; + CRingBuffer m_YSF; + bool m_dvsiEncode; + std::thread *vocoder_thread; + std::atomic_flag m_lock; + +}; + +#endif diff --git a/DSTAR2YSF/RingBuffer.h b/DSTAR2YSF/RingBuffer.h new file mode 100644 index 0000000..707de1c --- /dev/null +++ b/DSTAR2YSF/RingBuffer.h @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2006-2009,2012,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 RingBuffer_H +#define RingBuffer_H + +#include "Log.h" + +#include +#include +#include + +template class CRingBuffer { +public: + CRingBuffer(unsigned int length, const char* name) : + m_length(length), + m_name(name), + m_buffer(NULL), + m_iPtr(0U), + m_oPtr(0U) + { + assert(length > 0U); + assert(name != NULL); + + m_buffer = new T[length]; + + ::memset(m_buffer, 0x00, m_length * sizeof(T)); + } + + ~CRingBuffer() + { + delete[] m_buffer; + } + + bool addData(const T* buffer, unsigned int nSamples) + { + if (nSamples >= freeSpace()) { + LogError("%s buffer overflow, clearing the buffer. (%u >= %u)", m_name, nSamples, freeSpace()); + clear(); + return false; + } + + for (unsigned int i = 0U; i < nSamples; i++) { + m_buffer[m_iPtr++] = buffer[i]; + + if (m_iPtr == m_length) + m_iPtr = 0U; + } + + return true; + } + + bool getData(T* buffer, unsigned int nSamples) + { + if (dataSize() < nSamples) { + LogError("**** Underflow in %s ring buffer, %u < %u", m_name, dataSize(), nSamples); + return false; + } + + for (unsigned int i = 0U; i < nSamples; i++) { + buffer[i] = m_buffer[m_oPtr++]; + + if (m_oPtr == m_length) + m_oPtr = 0U; + } + + return true; + } + + bool peek(T* buffer, unsigned int nSamples) + { + if (dataSize() < nSamples) { + LogError("**** Underflow peek in %s ring buffer, %u < %u", m_name, dataSize(), nSamples); + return false; + } + + 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 true; + } + + void clear() + { + m_iPtr = 0U; + m_oPtr = 0U; + + ::memset(m_buffer, 0x00, m_length * sizeof(T)); + } + + unsigned int freeSpace() const + { + unsigned int len = m_length; + + if (m_oPtr > m_iPtr) + len = m_oPtr - m_iPtr; + else if (m_iPtr > m_oPtr) + len = m_length - (m_iPtr - m_oPtr); + + if (len > m_length) + len = 0U; + + return len; + } + + unsigned int dataSize() const + { + return m_length - freeSpace(); + } + + 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; + const char* m_name; + T* m_buffer; + unsigned int m_iPtr; + unsigned int m_oPtr; +}; + +#endif diff --git a/DSTAR2YSF/SerialController.cpp b/DSTAR2YSF/SerialController.cpp new file mode 100644 index 0000000..ab96102 --- /dev/null +++ b/DSTAR2YSF/SerialController.cpp @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2002-2004,2007-2011,2013,2014-2017,2019 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 + +#include + +#include +#include +#include +#include +#include +#include + +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); + + if (m_fd < 0) { + LogError("Cannot open device - %s", m_device.c_str()); + return false; + } + + if (::isatty(m_fd)) { + 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_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK); + termios.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL); + termios.c_iflag &= ~(IXON | IXOFF | IXANY); + termios.c_oflag &= ~(OPOST); + termios.c_cflag &= ~(CSTOPB | PARENB | CRTSCTS); + termios.c_cflag |= (CS8 | CLOCAL | CREAD); + termios.c_lflag &= ~(ISIG | ICANON | IEXTEN); + termios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL); + termios.c_cc[VMIN] = 0; + termios.c_cc[VTIME] = 1; + + 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; + case SERIAL_460800: + ::cfsetospeed(&termios, B460800); + ::cfsetispeed(&termios, B460800); + 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); + unsigned int ptr = 0; + /* + ssize_t len = ::read(m_fd, buffer, length); + if (len < 0) { + if (errno != EAGAIN) { + LogError("Error from read(), errno=%d", errno); + return -1; + } + } + ptr += len; + */ + //while(ptr < length){ + //ssize_t len = ::read(m_fd, buffer + ptr, length - ptr); + ssize_t len = ::read(m_fd, buffer, length); + if (len < 0) { + if (errno != EAGAIN) { + LogError("Error from read(), errno=%d", errno); + return -1; + } + } + //if (len > 0) + //ptr += len; + //} + + return len; +} + +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 len = ::write(m_fd, buffer + ptr, length - ptr); + if (len < 0) { + if (errno != EAGAIN) { + LogError("Error returned from write(), errno=%d", errno); + return -1; + } + } + + if (len > 0) + ptr += len; + } + + return ptr; +} + +void CSerialController::close() +{ + assert(m_fd != -1); + + ::close(m_fd); + m_fd = -1; +} diff --git a/DSTAR2YSF/SerialController.h b/DSTAR2YSF/SerialController.h new file mode 100644 index 0000000..adc3876 --- /dev/null +++ b/DSTAR2YSF/SerialController.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2002-2004,2007-2009,2011-2013,2015-2017 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 + + +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, + SERIAL_460800 = 460800 +}; + +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(); + +protected: + std::string m_device; + SERIAL_SPEED m_speed; + bool m_assertRTS; + int m_fd; +}; + +#endif diff --git a/DSTAR2YSF/StopWatch.cpp b/DSTAR2YSF/StopWatch.cpp new file mode 100644 index 0000000..481241b --- /dev/null +++ b/DSTAR2YSF/StopWatch.cpp @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2015,2016,2018 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_frequencyS(), +m_frequencyMS(), +m_start() +{ + ::QueryPerformanceFrequency(&m_frequencyS); + + m_frequencyMS.QuadPart = m_frequencyS.QuadPart / 1000ULL; +} + +CStopWatch::~CStopWatch() +{ +} + +unsigned long long CStopWatch::time() const +{ + LARGE_INTEGER now; + ::QueryPerformanceCounter(&now); + + return (unsigned long long)(now.QuadPart / m_frequencyMS.QuadPart); +} + +unsigned long long CStopWatch::start() +{ + ::QueryPerformanceCounter(&m_start); + + return (unsigned long long)(m_start.QuadPart / m_frequencyS.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_frequencyS.QuadPart); +} + +#else + +#include +#include + +CStopWatch::CStopWatch() : +m_startMS(0ULL) +{ +} + +CStopWatch::~CStopWatch() +{ +} + +unsigned long long CStopWatch::time() const +{ + struct timeval now; + ::gettimeofday(&now, NULL); + + return now.tv_sec * 1000ULL + now.tv_usec / 1000ULL; +} + +unsigned long long CStopWatch::start() +{ + struct timespec now; + ::clock_gettime(CLOCK_MONOTONIC, &now); + + m_startMS = now.tv_sec * 1000ULL + now.tv_nsec / 1000000ULL; + + return m_startMS; +} + +unsigned int CStopWatch::elapsed() +{ + struct timespec now; + ::clock_gettime(CLOCK_MONOTONIC, &now); + + unsigned long long nowMS = now.tv_sec * 1000ULL + now.tv_nsec / 1000000ULL; + + return nowMS - m_startMS; +} + +#endif diff --git a/DSTAR2YSF/StopWatch.h b/DSTAR2YSF/StopWatch.h new file mode 100644 index 0000000..3f8fa19 --- /dev/null +++ b/DSTAR2YSF/StopWatch.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2015,2016,2018 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 long time() const; + + unsigned long long start(); + unsigned int elapsed(); + +private: +#if defined(_WIN32) || defined(_WIN64) + LARGE_INTEGER m_frequencyS; + LARGE_INTEGER m_frequencyMS; + LARGE_INTEGER m_start; +#else + unsigned long long m_startMS; +#endif +}; + +#endif diff --git a/DSTAR2YSF/Timer.cpp b/DSTAR2YSF/Timer.cpp new file mode 100644 index 0000000..53956e4 --- /dev/null +++ b/DSTAR2YSF/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/DSTAR2YSF/Timer.h b/DSTAR2YSF/Timer.h new file mode 100644 index 0000000..87d68f5 --- /dev/null +++ b/DSTAR2YSF/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/DSTAR2YSF/UDPSocket.cpp b/DSTAR2YSF/UDPSocket.cpp new file mode 100644 index 0000000..396f1f7 --- /dev/null +++ b/DSTAR2YSF/UDPSocket.cpp @@ -0,0 +1,262 @@ +/* + * 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()); + +#if defined(_WIN32) || defined(_WIN64) + WSAData data; + int wsaRet = ::WSAStartup(MAKEWORD(2, 2), &data); + if (wsaRet != 0) + LogError("Error from WSAStartup"); +#endif +} + +CUDPSocket::CUDPSocket(unsigned int port) : +m_address(), +m_port(port), +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/DSTAR2YSF/UDPSocket.h b/DSTAR2YSF/UDPSocket.h new file mode 100644 index 0000000..e0af272 --- /dev/null +++ b/DSTAR2YSF/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 = 0U); + CUDPSocket(unsigned int port = 0U); + ~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/DSTAR2YSF/Utils.cpp b/DSTAR2YSF/Utils.cpp new file mode 100644 index 0000000..49ded13 --- /dev/null +++ b/DSTAR2YSF/Utils.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2009,2014,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 "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) +{ + assert(bits != NULL); + + 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) +{ + assert(bits != NULL); + + 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) +{ + assert(bits != NULL); + + 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) +{ + assert(bits != NULL); + + 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/DSTAR2YSF/Utils.h b/DSTAR2YSF/Utils.h new file mode 100644 index 0000000..ade28c0 --- /dev/null +++ b/DSTAR2YSF/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/DSTAR2YSF/Version.h b/DSTAR2YSF/Version.h new file mode 100644 index 0000000..36efd6b --- /dev/null +++ b/DSTAR2YSF/Version.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 = "20200605"; + +#endif diff --git a/DSTAR2YSF/YSFConvolution.cpp b/DSTAR2YSF/YSFConvolution.cpp new file mode 100644 index 0000000..23b117e --- /dev/null +++ b/DSTAR2YSF/YSFConvolution.cpp @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2009-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 "YSFConvolution.h" + +#include +#include +#include + +const unsigned char BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U}; + +#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7]) +#define READ_BIT1(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) + +const uint8_t BRANCH_TABLE1[] = {0U, 0U, 0U, 0U, 1U, 1U, 1U, 1U}; +const uint8_t BRANCH_TABLE2[] = {0U, 1U, 1U, 0U, 0U, 1U, 1U, 0U}; + +const unsigned int NUM_OF_STATES_D2 = 8U; +const unsigned int NUM_OF_STATES = 16U; +const uint32_t M = 2U; +const unsigned int K = 5U; + +CYSFConvolution::CYSFConvolution() : +m_metrics1(NULL), +m_metrics2(NULL), +m_oldMetrics(NULL), +m_newMetrics(NULL), +m_decisions(NULL), +m_dp(NULL) +{ + m_metrics1 = new uint16_t[16U]; + m_metrics2 = new uint16_t[16U]; + m_decisions = new uint64_t[180U]; +} + +CYSFConvolution::~CYSFConvolution() +{ + delete[] m_metrics1; + delete[] m_metrics2; + delete[] m_decisions; +} + +void CYSFConvolution::start() +{ + ::memset(m_metrics1, 0x00U, NUM_OF_STATES * sizeof(uint16_t)); + ::memset(m_metrics2, 0x00U, NUM_OF_STATES * sizeof(uint16_t)); + + m_oldMetrics = m_metrics1; + m_newMetrics = m_metrics2; + m_dp = m_decisions; +} + +void CYSFConvolution::decode(uint8_t s0, uint8_t s1) +{ + *m_dp = 0U; + + for (uint8_t i = 0U; i < NUM_OF_STATES_D2; i++) { + uint8_t j = i * 2U; + + uint16_t metric = (BRANCH_TABLE1[i] ^ s0) + (BRANCH_TABLE2[i] ^ s1); + + uint16_t m0 = m_oldMetrics[i] + metric; + uint16_t m1 = m_oldMetrics[i + NUM_OF_STATES_D2] + (M - metric); + uint8_t decision0 = (m0 >= m1) ? 1U : 0U; + m_newMetrics[j + 0U] = decision0 != 0U ? m1 : m0; + + m0 = m_oldMetrics[i] + (M - metric); + m1 = m_oldMetrics[i + NUM_OF_STATES_D2] + metric; + uint8_t decision1 = (m0 >= m1) ? 1U : 0U; + m_newMetrics[j + 1U] = decision1 != 0U ? m1 : m0; + + *m_dp |= (uint64_t(decision1) << (j + 1U)) | (uint64_t(decision0) << (j + 0U)); + } + + ++m_dp; + + assert((m_dp - m_decisions) <= 180); + + uint16_t* tmp = m_oldMetrics; + m_oldMetrics = m_newMetrics; + m_newMetrics = tmp; +} + +void CYSFConvolution::chainback(unsigned char* out, unsigned int nBits) +{ + assert(out != NULL); + + uint32_t state = 0U; + + while (nBits-- > 0) { + --m_dp; + + uint32_t i = state >> (9 - K); + uint8_t bit = uint8_t(*m_dp >> i) & 1; + state = (bit << 7) | (state >> 1); + + WRITE_BIT1(out, nBits, bit != 0U); + } +} + +void CYSFConvolution::encode(const unsigned char* in, unsigned char* out, unsigned int nBits) const +{ + assert(in != NULL); + assert(out != NULL); + assert(nBits > 0U); + + uint8_t d1 = 0U, d2 = 0U, d3 = 0U, d4 = 0U; + uint32_t k = 0U; + for (unsigned int i = 0U; i < nBits; i++) { + uint8_t d = READ_BIT1(in, i) ? 1U : 0U; + + uint8_t g1 = (d + d3 + d4) & 1; + uint8_t g2 = (d + d1 + d2 + d4) & 1; + + d4 = d3; + d3 = d2; + d2 = d1; + d1 = d; + + WRITE_BIT1(out, k, g1 != 0U); + k++; + + WRITE_BIT1(out, k, g2 != 0U); + k++; + } +} diff --git a/DSTAR2YSF/YSFConvolution.h b/DSTAR2YSF/YSFConvolution.h new file mode 100644 index 0000000..3fc4956 --- /dev/null +++ b/DSTAR2YSF/YSFConvolution.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(YSFConvolution_H) +#define YSFConvolution_H + +#include "YSFConvolution.h" + +#include + +class CYSFConvolution { +public: + CYSFConvolution(); + ~CYSFConvolution(); + + void start(); + void decode(uint8_t s0, uint8_t s1); + void chainback(unsigned char* out, unsigned int nBits); + + void encode(const unsigned char* in, unsigned char* out, unsigned int nBits) const; + +private: + uint16_t* m_metrics1; + uint16_t* m_metrics2; + uint16_t* m_oldMetrics; + uint16_t* m_newMetrics; + uint64_t* m_decisions; + uint64_t* m_dp; +}; + +#endif + diff --git a/DSTAR2YSF/YSFDefines.h b/DSTAR2YSF/YSFDefines.h new file mode 100644 index 0000000..348d1bc --- /dev/null +++ b/DSTAR2YSF/YSFDefines.h @@ -0,0 +1,49 @@ +/* + * 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(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 int YSF_SYNC_LENGTH_BYTES = 5U; + +const unsigned int YSF_FICH_LENGTH_BYTES = 25U; + +const unsigned char YSF_SYNC_OK = 0x01U; + +const unsigned int YSF_CALLSIGN_LENGTH = 10U; + +const unsigned char YSF_FI_HEADER = 0x00U; +const unsigned char YSF_FI_COMMUNICATIONS = 0x01U; +const unsigned char YSF_FI_TERMINATOR = 0x02U; +const unsigned char YSF_FI_TEST = 0x03U; + +const unsigned char YSF_DT_VD_MODE1 = 0x00U; +const unsigned char YSF_DT_DATA_FR_MODE = 0x01U; +const unsigned char YSF_DT_VD_MODE2 = 0x02U; +const unsigned char YSF_DT_VOICE_FR_MODE = 0x03U; + +const unsigned char YSF_CM_GROUP = 0x00U; +const unsigned char YSF_CM_INDIVIDUAL = 0x03U; + +const unsigned char YSF_MR_NOT_BUSY = 0x01U; +const unsigned char YSF_MR_BUSY = 0x02U; + +#endif diff --git a/DSTAR2YSF/YSFFICH.cpp b/DSTAR2YSF/YSFFICH.cpp new file mode 100644 index 0000000..07b07da --- /dev/null +++ b/DSTAR2YSF/YSFFICH.cpp @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2009-2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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 "YSFConvolution.h" +#include "YSFDefines.h" +#include "Golay24128.h" +#include "YSFFICH.h" +#include "CRC.h" +#include "Log.h" + +#include +#include +#include + +const unsigned char BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U}; + +#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7]) +#define READ_BIT1(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) + +const unsigned int INTERLEAVE_TABLE[] = { + 0U, 40U, 80U, 120U, 160U, + 2U, 42U, 82U, 122U, 162U, + 4U, 44U, 84U, 124U, 164U, + 6U, 46U, 86U, 126U, 166U, + 8U, 48U, 88U, 128U, 168U, + 10U, 50U, 90U, 130U, 170U, + 12U, 52U, 92U, 132U, 172U, + 14U, 54U, 94U, 134U, 174U, + 16U, 56U, 96U, 136U, 176U, + 18U, 58U, 98U, 138U, 178U, + 20U, 60U, 100U, 140U, 180U, + 22U, 62U, 102U, 142U, 182U, + 24U, 64U, 104U, 144U, 184U, + 26U, 66U, 106U, 146U, 186U, + 28U, 68U, 108U, 148U, 188U, + 30U, 70U, 110U, 150U, 190U, + 32U, 72U, 112U, 152U, 192U, + 34U, 74U, 114U, 154U, 194U, + 36U, 76U, 116U, 156U, 196U, + 38U, 78U, 118U, 158U, 198U}; + +CYSFFICH::CYSFFICH() : +m_fich(NULL) +{ + m_fich = new unsigned char[6U]; +} + +CYSFFICH::~CYSFFICH() +{ + delete[] m_fich; +} + +bool CYSFFICH::decode(const unsigned char* bytes) +{ + assert(bytes != NULL); + + // Skip the sync bytes + bytes += YSF_SYNC_LENGTH_BYTES; + + CYSFConvolution viterbi; + viterbi.start(); + + // Deinterleave the FICH and send bits to the Viterbi decoder + for (unsigned int i = 0U; i < 100U; i++) { + unsigned int n = INTERLEAVE_TABLE[i]; + uint8_t s0 = READ_BIT1(bytes, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(bytes, n) ? 1U : 0U; + + viterbi.decode(s0, s1); + } + + unsigned char output[13U]; + viterbi.chainback(output, 96U); + + unsigned int b0 = CGolay24128::decode24128(output + 0U); + unsigned int b1 = CGolay24128::decode24128(output + 3U); + unsigned int b2 = CGolay24128::decode24128(output + 6U); + unsigned int b3 = CGolay24128::decode24128(output + 9U); + + m_fich[0U] = (b0 >> 4) & 0xFFU; + m_fich[1U] = ((b0 << 4) & 0xF0U) | ((b1 >> 8) & 0x0FU); + m_fich[2U] = (b1 >> 0) & 0xFFU; + m_fich[3U] = (b2 >> 4) & 0xFFU; + m_fich[4U] = ((b2 << 4) & 0xF0U) | ((b3 >> 8) & 0x0FU); + m_fich[5U] = (b3 >> 0) & 0xFFU; + + return CCRC::checkCCITT162(m_fich, 6U); +} + +void CYSFFICH::encode(unsigned char* bytes) +{ + assert(bytes != NULL); + + // Skip the sync bytes + bytes += YSF_SYNC_LENGTH_BYTES; + + CCRC::addCCITT162(m_fich, 6U); + + unsigned int b0 = ((m_fich[0U] << 4) & 0xFF0U) | ((m_fich[1U] >> 4) & 0x00FU); + unsigned int b1 = ((m_fich[1U] << 8) & 0xF00U) | ((m_fich[2U] >> 0) & 0x0FFU); + unsigned int b2 = ((m_fich[3U] << 4) & 0xFF0U) | ((m_fich[4U] >> 4) & 0x00FU); + unsigned int b3 = ((m_fich[4U] << 8) & 0xF00U) | ((m_fich[5U] >> 0) & 0x0FFU); + + unsigned int c0 = CGolay24128::encode24128(b0); + unsigned int c1 = CGolay24128::encode24128(b1); + unsigned int c2 = CGolay24128::encode24128(b2); + unsigned int c3 = CGolay24128::encode24128(b3); + + unsigned char conv[13U]; + conv[0U] = (c0 >> 16) & 0xFFU; + conv[1U] = (c0 >> 8) & 0xFFU; + conv[2U] = (c0 >> 0) & 0xFFU; + conv[3U] = (c1 >> 16) & 0xFFU; + conv[4U] = (c1 >> 8) & 0xFFU; + conv[5U] = (c1 >> 0) & 0xFFU; + conv[6U] = (c2 >> 16) & 0xFFU; + conv[7U] = (c2 >> 8) & 0xFFU; + conv[8U] = (c2 >> 0) & 0xFFU; + conv[9U] = (c3 >> 16) & 0xFFU; + conv[10U] = (c3 >> 8) & 0xFFU; + conv[11U] = (c3 >> 0) & 0xFFU; + conv[12U] = 0x00U; + + CYSFConvolution convolution; + unsigned char convolved[25U]; + convolution.encode(conv, convolved, 100U); + + unsigned int j = 0U; + for (unsigned int i = 0U; i < 100U; i++) { + unsigned int n = INTERLEAVE_TABLE[i]; + + bool s0 = READ_BIT1(convolved, j) != 0U; + j++; + + bool s1 = READ_BIT1(convolved, j) != 0U; + j++; + + WRITE_BIT1(bytes, n, s0); + + n++; + WRITE_BIT1(bytes, n, s1); + } +} + +unsigned char CYSFFICH::getFI() const +{ + return (m_fich[0U] >> 6) & 0x03U; +} + +unsigned char CYSFFICH::getCS() const +{ + return (m_fich[0U] >> 4) & 0x03U; +} + +unsigned char CYSFFICH::getCM() const +{ + return (m_fich[0U] >> 2) & 0x03U; +} + +unsigned char CYSFFICH::getBN() const +{ + return m_fich[0U] & 0x03U; +} + +unsigned char CYSFFICH::getBT() const +{ + return (m_fich[1U] >> 6) & 0x03U; +} + +unsigned char CYSFFICH::getFN() const +{ + return (m_fich[1U] >> 3) & 0x07U; +} + +unsigned char CYSFFICH::getFT() const +{ + return m_fich[1U] & 0x07U; +} + +unsigned char CYSFFICH::getDT() const +{ + return m_fich[2U] & 0x03U; +} + +unsigned char CYSFFICH::getMR() const +{ + return (m_fich[2U] >> 3) & 0x03U; +} + +bool CYSFFICH::getDev() const +{ + return (m_fich[2U] & 0x40U) == 0x40U; +} + +bool CYSFFICH::getSQL() const +{ + return (m_fich[3U] & 0x80U) == 0x80U; +} + +unsigned char CYSFFICH::getSQ() const +{ + return m_fich[3U] & 0x7FU; +} + +void CYSFFICH::setFI(unsigned char fi) +{ + m_fich[0U] &= 0x3FU; + m_fich[0U] |= (fi << 6) & 0xC0U; +} + +void CYSFFICH::setCS(unsigned char cs) +{ + m_fich[0U] &= 0xCFU; + m_fich[0U] |= (cs << 4) & 0x30U; +} + +void CYSFFICH::setCM(unsigned char cm) +{ + m_fich[0U] &= 0xF3U; + m_fich[0U] |= (cm << 2) & 0x0CU; +} + +void CYSFFICH::setFN(unsigned char fn) +{ + m_fich[1U] &= 0xC7U; + m_fich[1U] |= (fn << 3) & 0x38U; +} + +void CYSFFICH::setFT(unsigned char ft) +{ + m_fich[1U] &= 0xF8U; + m_fich[1U] |= ft & 0x07U; +} + +void CYSFFICH::setMR(unsigned char mr) +{ + m_fich[2U] &= 0xC7U; + m_fich[2U] |= (mr << 3) & 0x38U; +} + +void CYSFFICH::setVoIP(bool on) +{ + if (on) + m_fich[2U] |= 0x04U; + else + m_fich[2U] &= 0xFBU; +} + +void CYSFFICH::setDev(bool on) +{ + if (on) + m_fich[2U] |= 0x40U; + else + m_fich[2U] &= 0xBFU; +} + +void CYSFFICH::setDT(unsigned char dt) +{ + m_fich[2U] &= 0xFCU; + m_fich[2U] |= dt & 0x03U; +} + +void CYSFFICH::setSQL(bool on) +{ + if (on) + m_fich[3U] |= 0x80U; + else + m_fich[3U] &= 0x7FU; +} + +void CYSFFICH::setSQ(unsigned char sq) +{ + m_fich[3U] &= 0x80U; + m_fich[3U] |= sq & 0x7FU; +} + +void CYSFFICH::setBN(unsigned char bn) +{ + m_fich[0U] &= 0xFCU; + m_fich[0U] |= bn & 0x03U; +} + +void CYSFFICH::setBT(unsigned char bt) +{ + m_fich[1U] &= 0x3FU; + m_fich[1U] |= (bt << 6) & 0xC0U; +} + +void CYSFFICH::load(const unsigned char* fich) +{ + assert(fich != NULL); + + ::memcpy(m_fich, fich, 4U); +} + diff --git a/DSTAR2YSF/YSFFICH.h b/DSTAR2YSF/YSFFICH.h new file mode 100644 index 0000000..d349886 --- /dev/null +++ b/DSTAR2YSF/YSFFICH.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2015,2016 by Jonathan Naylor G4KLX + * Copyright (C) 2018 by Andy Uribe CA6JAU + * + * 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(YSFFICH_H) +#define YSFFICH_H + +class CYSFFICH { +public: + CYSFFICH(); + ~CYSFFICH(); + + bool decode(const unsigned char* bytes); + + void encode(unsigned char* bytes); + + unsigned char getFI() const; + unsigned char getCS() const; + unsigned char getCM() const; + unsigned char getBN() const; + unsigned char getBT() const; + unsigned char getFN() const; + unsigned char getFT() const; + unsigned char getDT() const; + unsigned char getMR() const; + bool getDev() const; + bool getSQL() const; + unsigned char getSQ() const; + + void setFI(unsigned char fi); + void setCS(unsigned char cs); + void setCM(unsigned char cm); + void setFN(unsigned char fn); + void setFT(unsigned char ft); + void setBN(unsigned char bn); + void setBT(unsigned char bt); + void setDT(unsigned char dt); + void setMR(unsigned char mr); + void setVoIP(bool set); + void setDev(bool set); + void setSQL(bool set); + void setSQ(unsigned char sq); + + void load(const unsigned char* fich); + +private: + unsigned char* m_fich; +}; + +#endif diff --git a/DSTAR2YSF/YSFNetwork.cpp b/DSTAR2YSF/YSFNetwork.cpp new file mode 100644 index 0000000..050a1fa --- /dev/null +++ b/DSTAR2YSF/YSFNetwork.cpp @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2009-2014,2016,2017 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 "YSFNetwork.h" +#include "Utils.h" +#include "Log.h" + +#include +#include +#include + +const unsigned int BUFFER_LENGTH = 200U; + +CYSFNetwork::CYSFNetwork(const std::string& address, unsigned int port, const std::string& callsign, bool debug) : +m_socket(address, port), +m_debug(debug), +m_address(), +m_port(0U), +m_poll(NULL), +m_unlink(NULL), +m_buffer(1000U, "YSF Network Buffer") +{ + m_poll = new unsigned char[14U]; + ::memcpy(m_poll + 0U, "YSFP", 4U); + + m_unlink = new unsigned char[14U]; + ::memcpy(m_unlink + 0U, "YSFU", 4U); + + m_callsign = callsign; + m_callsign.resize(YSF_CALLSIGN_LENGTH, ' '); + + for (unsigned int i = 0U; i < YSF_CALLSIGN_LENGTH; i++) { + m_poll[i + 4U] = m_callsign.at(i); + m_unlink[i + 4U] = m_callsign.at(i); + } +} + +CYSFNetwork::CYSFNetwork(unsigned int port, const std::string& callsign, bool debug) : +m_socket(port), +m_debug(debug), +m_address(), +m_port(0U), +m_poll(NULL), +m_unlink(NULL), +m_buffer(1000U, "YSF Network Buffer") +{ + m_poll = new unsigned char[14U]; + ::memcpy(m_poll + 0U, "YSFP", 4U); + + m_unlink = new unsigned char[14U]; + ::memcpy(m_unlink + 0U, "YSFU", 4U); + + m_callsign = callsign; + m_callsign.resize(YSF_CALLSIGN_LENGTH, ' '); + + for (unsigned int i = 0U; i < YSF_CALLSIGN_LENGTH; i++) { + m_poll[i + 4U] = m_callsign.at(i); + m_unlink[i + 4U] = m_callsign.at(i); + } +} + +CYSFNetwork::~CYSFNetwork() +{ + delete[] m_poll; +} + +std::string CYSFNetwork::getCallsign() +{ + return m_callsign; +} + +bool CYSFNetwork::open() +{ + LogMessage("Opening YSF network connection"); + + return m_socket.open(); +} + +void CYSFNetwork::setDestination(const in_addr& address, unsigned int port) +{ + m_address = address; + m_port = port; +} + +void CYSFNetwork::clearDestination() +{ + m_address.s_addr = INADDR_NONE; + m_port = 0U; +} + +bool CYSFNetwork::write(const unsigned char* data) +{ + assert(data != NULL); + + if (m_port == 0U) + return true; + + if (m_debug) + CUtils::dump(1U, "YSF Network Data Sent", data, 155U); + + return m_socket.write(data, 155U, m_address, m_port); +} + +bool CYSFNetwork::writePoll() +{ + if (m_port == 0U) + return true; + + return m_socket.write(m_poll, 14U, m_address, m_port); +} + +bool CYSFNetwork::writeUnlink() +{ + if (m_port == 0U) + return true; + + return m_socket.write(m_unlink, 14U, m_address, m_port); +} + +void CYSFNetwork::clock(unsigned int ms) +{ + if (m_port == 0U) + return; + + unsigned char buffer[BUFFER_LENGTH]; + + in_addr address; + unsigned int port; + int length = m_socket.read(buffer, BUFFER_LENGTH, address, port); + if (length <= 0) + return; + + if (address.s_addr != m_address.s_addr || port != m_port) + return; + + if (m_debug) + CUtils::dump(1U, "YSF Network Data Received", buffer, length); + + unsigned char len = length; + m_buffer.addData(&len, 1U); + + m_buffer.addData(buffer, length); +} + +unsigned int CYSFNetwork::read(unsigned char* data) +{ + assert(data != NULL); + + if (m_buffer.isEmpty()) + return 0U; + + unsigned char len = 0U; + m_buffer.getData(&len, 1U); + + m_buffer.getData(data, len); + + return len; +} + +void CYSFNetwork::close() +{ + m_socket.close(); + + LogMessage("Closing YSF network connection"); +} diff --git a/DSTAR2YSF/YSFNetwork.h b/DSTAR2YSF/YSFNetwork.h new file mode 100644 index 0000000..39810c4 --- /dev/null +++ b/DSTAR2YSF/YSFNetwork.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2009-2014,2016,2017 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(YSFNETWORK_H) +#define YSFNETWORK_H + +#include "YSFDefines.h" +#include "UDPSocket.h" +#include "RingBuffer.h" + +#include +#include + +class CYSFNetwork { +public: + CYSFNetwork(const std::string& address, unsigned int port, const std::string& callsign, bool debug); + CYSFNetwork(unsigned int port, const std::string& callsign, bool debug); + ~CYSFNetwork(); + + bool open(); + + std::string getCallsign(); + + void setDestination(const in_addr& address, unsigned int port); + void clearDestination(); + + bool write(const unsigned char* data); + + bool writePoll(); + bool writeUnlink(); + + unsigned int read(unsigned char* data); + + void clock(unsigned int ms); + + void close(); + +private: + std::string m_callsign; + CUDPSocket m_socket; + bool m_debug; + in_addr m_address; + unsigned int m_port; + unsigned char* m_poll; + unsigned char* m_unlink; + CRingBuffer m_buffer; +}; + +#endif diff --git a/DSTAR2YSF/YSFPayload.cpp b/DSTAR2YSF/YSFPayload.cpp new file mode 100644 index 0000000..2f07b63 --- /dev/null +++ b/DSTAR2YSF/YSFPayload.cpp @@ -0,0 +1,626 @@ +/* +* Copyright (C) 2016,2017 Jonathan Naylor, G4KLX +* Copyright (C) 2016 Mathias Weyland, HB9FRV +* +* 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 "YSFConvolution.h" +#include "YSFPayload.h" +#include "YSFDefines.h" +#include "Utils.h" +#include "CRC.h" +#include "Log.h" + +#include +#include +#include +#include + +const unsigned int INTERLEAVE_TABLE_9_20[] = { + 0U, 40U, 80U, 120U, 160U, 200U, 240U, 280U, 320U, + 2U, 42U, 82U, 122U, 162U, 202U, 242U, 282U, 322U, + 4U, 44U, 84U, 124U, 164U, 204U, 244U, 284U, 324U, + 6U, 46U, 86U, 126U, 166U, 206U, 246U, 286U, 326U, + 8U, 48U, 88U, 128U, 168U, 208U, 248U, 288U, 328U, + 10U, 50U, 90U, 130U, 170U, 210U, 250U, 290U, 330U, + 12U, 52U, 92U, 132U, 172U, 212U, 252U, 292U, 332U, + 14U, 54U, 94U, 134U, 174U, 214U, 254U, 294U, 334U, + 16U, 56U, 96U, 136U, 176U, 216U, 256U, 296U, 336U, + 18U, 58U, 98U, 138U, 178U, 218U, 258U, 298U, 338U, + 20U, 60U, 100U, 140U, 180U, 220U, 260U, 300U, 340U, + 22U, 62U, 102U, 142U, 182U, 222U, 262U, 302U, 342U, + 24U, 64U, 104U, 144U, 184U, 224U, 264U, 304U, 344U, + 26U, 66U, 106U, 146U, 186U, 226U, 266U, 306U, 346U, + 28U, 68U, 108U, 148U, 188U, 228U, 268U, 308U, 348U, + 30U, 70U, 110U, 150U, 190U, 230U, 270U, 310U, 350U, + 32U, 72U, 112U, 152U, 192U, 232U, 272U, 312U, 352U, + 34U, 74U, 114U, 154U, 194U, 234U, 274U, 314U, 354U, + 36U, 76U, 116U, 156U, 196U, 236U, 276U, 316U, 356U, + 38U, 78U, 118U, 158U, 198U, 238U, 278U, 318U, 358U}; + +const unsigned int INTERLEAVE_TABLE_5_20[] = { + 0U, 40U, 80U, 120U, 160U, + 2U, 42U, 82U, 122U, 162U, + 4U, 44U, 84U, 124U, 164U, + 6U, 46U, 86U, 126U, 166U, + 8U, 48U, 88U, 128U, 168U, + 10U, 50U, 90U, 130U, 170U, + 12U, 52U, 92U, 132U, 172U, + 14U, 54U, 94U, 134U, 174U, + 16U, 56U, 96U, 136U, 176U, + 18U, 58U, 98U, 138U, 178U, + 20U, 60U, 100U, 140U, 180U, + 22U, 62U, 102U, 142U, 182U, + 24U, 64U, 104U, 144U, 184U, + 26U, 66U, 106U, 146U, 186U, + 28U, 68U, 108U, 148U, 188U, + 30U, 70U, 110U, 150U, 190U, + 32U, 72U, 112U, 152U, 192U, + 34U, 74U, 114U, 154U, 194U, + 36U, 76U, 116U, 156U, 196U, + 38U, 78U, 118U, 158U, 198U}; + +// This one differs from the others in that it interleaves bits and not dibits +const unsigned char WHITENING_DATA[] = {0x93U, 0xD7U, 0x51U, 0x21U, 0x9CU, 0x2FU, 0x6CU, 0xD0U, 0xEFU, 0x0FU, + 0xF8U, 0x3DU, 0xF1U, 0x73U, 0x20U, 0x94U, 0xEDU, 0x1EU, 0x7CU, 0xD8U}; + +const unsigned char BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U}; + +#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7]) +#define READ_BIT1(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) + +CYSFPayload::CYSFPayload() : +m_uplink(NULL), +m_downlink(NULL), +m_source(NULL), +m_dest(NULL) +{ +} + +CYSFPayload::~CYSFPayload() +{ + delete[] m_uplink; + delete[] m_downlink; + delete[] m_source; + delete[] m_dest; +} + +bool CYSFPayload::processHeaderData(unsigned char* data) +{ + assert(data != NULL); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char dch[45U]; + + unsigned char* p1 = data; + unsigned char* p2 = dch; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p2, p1, 9U); + p1 += 18U; p2 += 9U; + } + + CYSFConvolution conv; + conv.start(); + + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + uint8_t s0 = READ_BIT1(dch, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(dch, n) ? 1U : 0U; + + conv.decode(s0, s1); + } + + unsigned char output[23U]; + conv.chainback(output, 176U); + + bool valid1 = CCRC::checkCCITT162(output, 22U); + if (valid1) { + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + if (m_dest == NULL) { + m_dest = new unsigned char[YSF_CALLSIGN_LENGTH]; + ::memcpy(m_dest, output + 0U, YSF_CALLSIGN_LENGTH); + } + + if (m_source == NULL) { + m_source = new unsigned char[YSF_CALLSIGN_LENGTH]; + ::memcpy(m_source, output + YSF_CALLSIGN_LENGTH, YSF_CALLSIGN_LENGTH); + } + + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + CCRC::addCCITT162(output, 22U); + output[22U] = 0x00U; + + unsigned char convolved[45U]; + conv.encode(output, convolved, 180U); + + unsigned char bytes[45U]; + unsigned int j = 0U; + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + + bool s0 = READ_BIT1(convolved, j) != 0U; + j++; + + bool s1 = READ_BIT1(convolved, j) != 0U; + j++; + + WRITE_BIT1(bytes, n, s0); + + n++; + WRITE_BIT1(bytes, n, s1); + } + + p1 = data; + p2 = bytes; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p1, p2, 9U); + p1 += 18U; p2 += 9U; + } + } + + p1 = data + 9U; + p2 = dch; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p2, p1, 9U); + p1 += 18U; p2 += 9U; + } + + conv.start(); + + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + uint8_t s0 = READ_BIT1(dch, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(dch, n) ? 1U : 0U; + + conv.decode(s0, s1); + } + + conv.chainback(output, 176U); + + bool valid2 = CCRC::checkCCITT162(output, 22U); + if (valid2) { + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + if (m_downlink != NULL) + ::memcpy(output + 0U, m_downlink, YSF_CALLSIGN_LENGTH); + + if (m_uplink != NULL) + ::memcpy(output + YSF_CALLSIGN_LENGTH, m_uplink, YSF_CALLSIGN_LENGTH); + + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + CCRC::addCCITT162(output, 22U); + output[22U] = 0x00U; + + unsigned char convolved[45U]; + conv.encode(output, convolved, 180U); + + unsigned char bytes[45U]; + unsigned int j = 0U; + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + + bool s0 = READ_BIT1(convolved, j) != 0U; + j++; + + bool s1 = READ_BIT1(convolved, j) != 0U; + j++; + + WRITE_BIT1(bytes, n, s0); + + n++; + WRITE_BIT1(bytes, n, s1); + } + + p1 = data + 9U; + p2 = bytes; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p1, p2, 9U); + p1 += 18U; p2 += 9U; + } + } + + return valid1; +} + +bool CYSFPayload::readDataFRModeData1(const unsigned char* data, unsigned char* dt) +{ + assert(data != NULL); + assert(dt != NULL); + + ::memset(dt, ' ', 20U); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char dch[45U]; + + const unsigned char* p1 = data; + unsigned char* p2 = dch; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p2, p1, 9U); + p1 += 18U; p2 += 9U; + } + + CYSFConvolution conv; + conv.start(); + + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + uint8_t s0 = READ_BIT1(dch, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(dch, n) ? 1U : 0U; + + conv.decode(s0, s1); + } + + unsigned char output[23U]; + conv.chainback(output, 176U); + + bool ret = CCRC::checkCCITT162(output, 22U); + if (ret) { + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + // CUtils::dump(1U, "FR Mode Data 1", output, 20U); + + ::memcpy(dt, output, 20U); + } + + return ret; +} + +bool CYSFPayload::readDataFRModeData2(const unsigned char* data, unsigned char* dt) +{ + assert(data != NULL); + assert(dt != NULL); + + ::memset(dt, ' ', 20U); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char dch[45U]; + + const unsigned char* p1 = data + 9U; + unsigned char* p2 = dch; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p2, p1, 9U); + p1 += 18U; p2 += 9U; + } + + CYSFConvolution conv; + conv.start(); + + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + uint8_t s0 = READ_BIT1(dch, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(dch, n) ? 1U : 0U; + + conv.decode(s0, s1); + } + + unsigned char output[23U]; + conv.chainback(output, 176U); + + bool ret = CCRC::checkCCITT162(output, 22U); + if (ret) { + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + // CUtils::dump(1U, "FR Mode Data 2", output, 20U); + + ::memcpy(dt, output, 20U); + } + + return ret; +} + +void CYSFPayload::writeVDMode2Data(unsigned char* data, const unsigned char* dt) +{ + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char dt_tmp[13]; + ::memcpy(dt_tmp, dt, YSF_CALLSIGN_LENGTH); + + for (unsigned int i = 0U; i < 10U; i++) + dt_tmp[i] ^= WHITENING_DATA[i]; + + CCRC::addCCITT162(dt_tmp, 12U); + dt_tmp[12U] = 0x00U; + + unsigned char convolved[25U]; + CYSFConvolution conv; + conv.start(); + conv.encode(dt_tmp, convolved, 100U); + + unsigned char bytes[25U]; + unsigned int j = 0U; + for (unsigned int i = 0U; i < 100U; i++) { + unsigned int n = INTERLEAVE_TABLE_5_20[i]; + + bool s0 = READ_BIT1(convolved, j) != 0U; + j++; + + bool s1 = READ_BIT1(convolved, j) != 0U; + j++; + + WRITE_BIT1(bytes, n, s0); + + n++; + WRITE_BIT1(bytes, n, s1); + } + + unsigned char* p1 = data; + unsigned char* p2 = bytes; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p1, p2, 5U); + p1 += 18U; p2 += 5U; + } +} + + +bool CYSFPayload::readVDMode1Data(const unsigned char* data, unsigned char* dt) +{ + assert(data != NULL); + assert(dt != NULL); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char dch[45U]; + + const unsigned char* p1 = data; + unsigned char* p2 = dch; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p2, p1, 9U); + p1 += 18U; p2 += 9U; + } + + CYSFConvolution conv; + conv.start(); + + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + uint8_t s0 = READ_BIT1(dch, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(dch, n) ? 1U : 0U; + + conv.decode(s0, s1); + } + + unsigned char output[23U]; + conv.chainback(output, 176U); + + bool ret = CCRC::checkCCITT162(output, 22U); + if (ret) { + for (unsigned int i = 0U; i < 20U; i++) + output[i] ^= WHITENING_DATA[i]; + + // CUtils::dump(1U, "V/D Mode 1 Data", output, 20U); + + ::memcpy(dt, output, 20U); + } + + return ret; +} + + +bool CYSFPayload::readVDMode2Data(const unsigned char* data, unsigned char* dt) +{ + assert(data != NULL); + assert(dt != NULL); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char dch[25U]; + + const unsigned char* p1 = data; + unsigned char* p2 = dch; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p2, p1, 5U); + p1 += 18U; p2 += 5U; + } + + CYSFConvolution conv; + conv.start(); + + for (unsigned int i = 0U; i < 100U; i++) { + unsigned int n = INTERLEAVE_TABLE_5_20[i]; + uint8_t s0 = READ_BIT1(dch, n) ? 1U : 0U; + + n++; + uint8_t s1 = READ_BIT1(dch, n) ? 1U : 0U; + + conv.decode(s0, s1); + } + + unsigned char output[13U]; + conv.chainback(output, 96U); + + bool ret = CCRC::checkCCITT162(output, 12U); + if (ret) { + for (unsigned int i = 0U; i < 10U; i++) + output[i] ^= WHITENING_DATA[i]; + + // CUtils::dump(1U, "V/D Mode 2 Data", output, YSF_CALLSIGN_LENGTH); + + ::memcpy(dt, output, YSF_CALLSIGN_LENGTH); + } + + return ret; +} + +void CYSFPayload::writeHeader(unsigned char* data, const unsigned char* csd1, const unsigned char* csd2) +{ + assert(data != NULL); + assert(csd1 != NULL); + assert(csd2 != NULL); + + writeDataFRModeData1(csd1, data); + + writeDataFRModeData2(csd2, data); +} + +void CYSFPayload::writeDataFRModeData1(const unsigned char* dt, unsigned char* data) +{ + assert(dt != NULL); + assert(data != NULL); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char output[25U]; + for (unsigned int i = 0U; i < 20U; i++) + output[i] = dt[i] ^ WHITENING_DATA[i]; + + CCRC::addCCITT162(output, 22U); + output[22U] = 0x00U; + + unsigned char convolved[45U]; + + CYSFConvolution conv; + conv.encode(output, convolved, 180U); + + unsigned char bytes[45U]; + unsigned int j = 0U; + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + + bool s0 = READ_BIT1(convolved, j) != 0U; + j++; + + bool s1 = READ_BIT1(convolved, j) != 0U; + j++; + + WRITE_BIT1(bytes, n, s0); + + n++; + WRITE_BIT1(bytes, n, s1); + } + + unsigned char* p1 = data; + unsigned char* p2 = bytes; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p1, p2, 9U); + p1 += 18U; p2 += 9U; + } +} + +void CYSFPayload::writeDataFRModeData2(const unsigned char* dt, unsigned char* data) +{ + assert(dt != NULL); + assert(data != NULL); + + data += YSF_SYNC_LENGTH_BYTES + YSF_FICH_LENGTH_BYTES; + + unsigned char output[25U]; + for (unsigned int i = 0U; i < 20U; i++) + output[i] = dt[i] ^ WHITENING_DATA[i]; + + CCRC::addCCITT162(output, 22U); + output[22U] = 0x00U; + + unsigned char convolved[45U]; + + CYSFConvolution conv; + conv.encode(output, convolved, 180U); + + unsigned char bytes[45U]; + unsigned int j = 0U; + for (unsigned int i = 0U; i < 180U; i++) { + unsigned int n = INTERLEAVE_TABLE_9_20[i]; + + bool s0 = READ_BIT1(convolved, j) != 0U; + j++; + + bool s1 = READ_BIT1(convolved, j) != 0U; + j++; + + WRITE_BIT1(bytes, n, s0); + + n++; + WRITE_BIT1(bytes, n, s1); + } + + unsigned char* p1 = data + 9U; + unsigned char* p2 = bytes; + for (unsigned int i = 0U; i < 5U; i++) { + ::memcpy(p1, p2, 9U); + p1 += 18U; p2 += 9U; + } +} + +void CYSFPayload::setUplink(const std::string& callsign) +{ + m_uplink = new unsigned char[YSF_CALLSIGN_LENGTH]; + + std::string uplink = callsign; + uplink.resize(YSF_CALLSIGN_LENGTH, ' '); + + for (unsigned int i = 0U; i < YSF_CALLSIGN_LENGTH; i++) + m_uplink[i] = uplink.at(i); +} + +void CYSFPayload::setDownlink(const std::string& callsign) +{ + m_downlink = new unsigned char[YSF_CALLSIGN_LENGTH]; + + std::string downlink = callsign; + downlink.resize(YSF_CALLSIGN_LENGTH, ' '); + + for (unsigned int i = 0U; i < YSF_CALLSIGN_LENGTH; i++) + m_downlink[i] = downlink.at(i); +} + +std::string CYSFPayload::getSource() +{ + std::string tmp; + + if (m_dest) + tmp.assign((const char *)m_source, YSF_CALLSIGN_LENGTH); + else + tmp = ""; + + return tmp; +} + +std::string CYSFPayload::getDest() +{ + std::string tmp; + + if (m_dest) + tmp.assign((const char *)m_dest, 5); + else + tmp = ""; + + return tmp; +} + +void CYSFPayload::reset() +{ + delete[] m_source; + delete[] m_dest; + + m_source = NULL; + m_dest = NULL; +} diff --git a/DSTAR2YSF/YSFPayload.h b/DSTAR2YSF/YSFPayload.h new file mode 100644 index 0000000..2acd54d --- /dev/null +++ b/DSTAR2YSF/YSFPayload.h @@ -0,0 +1,57 @@ +/* +* Copyright (C) 2016,2017 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(YSFPayload_H) +#define YSFPayload_H + +#include + +class CYSFPayload { +public: + CYSFPayload(); + ~CYSFPayload(); + + bool processHeaderData(unsigned char* bytes); + + void writeVDMode2Data(unsigned char* data, const unsigned char* dt); + bool readVDMode1Data(const unsigned char* data, unsigned char* dt); + bool readVDMode2Data(const unsigned char* data, unsigned char* dt); + + void writeHeader(unsigned char* data, const unsigned char* csd1, const unsigned char* csd2); + + void writeDataFRModeData1(const unsigned char* dt, unsigned char* data); + void writeDataFRModeData2(const unsigned char* dt, unsigned char* data); + bool readDataFRModeData1(const unsigned char* data, unsigned char* dt); + bool readDataFRModeData2(const unsigned char* data, unsigned char* dt); + + std::string getSource(); + std::string getDest(); + + void setUplink(const std::string& callsign); + void setDownlink(const std::string& callsign); + + void reset(); + +private: + unsigned char* m_uplink; + unsigned char* m_downlink; + unsigned char* m_source; + unsigned char* m_dest; +}; + +#endif diff --git a/P252DMR/P252DMR b/P252DMR/P252DMR new file mode 100755 index 0000000000000000000000000000000000000000..f980c099b6766d0482ad5a5dff235c8b60a47c6b GIT binary patch literal 2933908 zcmce<3w%`7x%a8{Z8<$~Iv2J

YwgwpDq*zdd_!JBJ?Mf8YNx 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

QoCl6m6RS0Feqo(0?(47J^vLXmVN! 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%0Dhd{CB@S0S&K4fjA)wumZ=T6@BemuuXn&M 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

VQa=;!Sn|LVFC6&b%J@z6bIY82Hazpn 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%0A+Imp8LET1oAKiUS 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