diff --git a/ambed/readme b/ambed/readme
index 04e5be8..6bdbca1 100644
--- a/ambed/readme
+++ b/ambed/readme
@@ -3,7 +3,7 @@
 //  ambed
 //
 //  Created by Jean-Luc Deltombe (LX3JL) on 09/07/2017.
-//  Copyright © 2017 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//  Copyright © 2017-2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
 //
 // ----------------------------------------------------------------------------
 //    This file is part of ambed.
diff --git a/src/cbuffer.cpp b/src/cbuffer.cpp
index 5213155..479abee 100644
--- a/src/cbuffer.cpp
+++ b/src/cbuffer.cpp
@@ -182,6 +182,7 @@ CBuffer::operator const char *() const
 
 void CBuffer::DebugDump(std::ofstream &debugout) const
 {
+    // dump an hex line
     for ( int i = 0; i < size(); i++ )
     {
         char sz[16];
@@ -199,3 +200,29 @@ void CBuffer::DebugDump(std::ofstream &debugout) const
     }
 }
 
+void CBuffer::DebugDumpAscii(std::ofstream &debugout) const
+{
+    // dump an ascii line
+    for ( int i = 0; i < size(); i++ )
+    {
+        char c = data()[i];
+        if ( isascii(c) )
+        {
+            debugout << c;
+        }
+        else
+        {
+            debugout << '.';
+        }
+        if ( i == size()-1 )
+        {
+            debugout << std::endl;
+        }
+        //else
+        //{
+        //    debugout << ',';
+        //}
+    }
+}
+
+
diff --git a/src/cbuffer.h b/src/cbuffer.h
index 95bbae9..ba4b967 100644
--- a/src/cbuffer.h
+++ b/src/cbuffer.h
@@ -62,6 +62,7 @@ public:
     
     // debug
     void DebugDump(std::ofstream &) const;
+    void DebugDumpAscii(std::ofstream &) const;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/ccrc.cpp b/src/ccrc.cpp
index c09ad1c..a69ed8d 100644
--- a/src/ccrc.cpp
+++ b/src/ccrc.cpp
@@ -237,3 +237,15 @@ unsigned char CCRC::crc8(const unsigned char *in, unsigned int length)
     
     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/src/ccrc.h b/src/ccrc.h
index 90491be..82730d4 100644
--- a/src/ccrc.h
+++ b/src/ccrc.h
@@ -32,6 +32,8 @@ public:
     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/src/cdmriddir.h b/src/cdmriddir.h
index 1e0d9ed..23334e3 100644
--- a/src/cdmriddir.h
+++ b/src/cdmriddir.h
@@ -34,7 +34,7 @@
 
 // compare function for std::map::find
 
-struct CallsignCompare
+struct CDmridDirCallsignCompare
 {
     bool operator() (const CCallsign &cs1, const CCallsign &cs2) const
     { return cs1.HasLowerCallsign(cs2);}
@@ -80,7 +80,7 @@ protected:
 protected:
 	// data
     std::map <uint32, CCallsign> m_CallsignMap;
-    std::map <CCallsign, uint32, CallsignCompare> m_DmridMap;
+    std::map <CCallsign, uint32, CDmridDirCallsignCompare> m_DmridMap;
     
     // Lock()
     std::mutex          m_Mutex;
diff --git a/src/cdmriddirfile.cpp b/src/cdmriddirfile.cpp
index 0efb26e..29a921b 100644
--- a/src/cdmriddirfile.cpp
+++ b/src/cdmriddirfile.cpp
@@ -144,7 +144,7 @@ bool CDmridDirFile::RefreshContent(const CBuffer &buffer)
     }
     
     // report
-    std::cout << "Read " << m_DmridMap.size() << " DMR id from file " << DMRIDDB_PATH << std::endl;
+    std::cout << "Read " << m_DmridMap.size() << " DMR ids from file " << DMRIDDB_PATH << std::endl;
     
     // done
     return ok;
diff --git a/src/cdmriddirhttp.cpp b/src/cdmriddirhttp.cpp
index 12f21a0..f92246a 100644
--- a/src/cdmriddirhttp.cpp
+++ b/src/cdmriddirhttp.cpp
@@ -85,7 +85,7 @@ bool CDmridDirHttp::RefreshContent(const CBuffer &buffer)
     }
     
     // report
-    std::cout << "Read " << m_DmridMap.size() << " DMR id from xlxapi.rlx.lu database " << std::endl;
+    std::cout << "Read " << m_DmridMap.size() << " DMR ids from xlxapi.rlx.lu database " << std::endl;
     
     // done
     return ok;
@@ -96,7 +96,6 @@ bool CDmridDirHttp::RefreshContent(const CBuffer &buffer)
 // httpd helpers
 
 #define DMRID_HTTPGET_SIZEMAX       (256)
-#define DMRID_TEXTFILE_SIZEMAX      (10*1024*1024)
 
 bool CDmridDirHttp::HttpGet(const char *hostname, const char *filename, int port, CBuffer *buffer)
 {
diff --git a/src/cdvframepacket.cpp b/src/cdvframepacket.cpp
index 113aba4..8c2e02b 100644
--- a/src/cdvframepacket.cpp
+++ b/src/cdvframepacket.cpp
@@ -61,13 +61,24 @@ CDvFramePacket::CDvFramePacket(const uint8 *ambe, const uint8 *sync, uint16 sid,
     ::memset(m_uiDvData, 0, sizeof(m_uiDvData));
 }
 
-// dstar + dmr constructor
+// ysf constructor
+
+CDvFramePacket::CDvFramePacket(const uint8 *ambe, uint16 sid, uint8 pid, uint8 spid, uint8 fid)
+: CPacket(sid, pid, spid, fid)
+{
+    ::memcpy(m_uiAmbePlus, ambe, sizeof(m_uiAmbePlus));
+    ::memset(m_uiDvSync, 0, sizeof(m_uiDvSync));
+    ::memset(m_uiAmbe, 0, sizeof(m_uiAmbe));
+    ::memset(m_uiDvData, 0, sizeof(m_uiDvData));
+}
+
+// xlx constructor
 
 CDvFramePacket::CDvFramePacket
     (uint16 sid,
      uint8 dstarpid, const uint8 *dstarambe, const uint8 *dstardvdata,
      uint8 dmrpid, uint8 dprspid, const uint8 *dmrambe, const uint8 *dmrsync)
-: CPacket(sid, dstarpid, dmrpid, dprspid)
+: CPacket(sid, dstarpid, dmrpid, dprspid, 0xFF, 0xFF, 0xFF)
 {
     ::memcpy(m_uiAmbe, dstarambe, sizeof(m_uiAmbe));
     ::memcpy(m_uiDvData, dstardvdata, sizeof(m_uiDvData));
diff --git a/src/cdvframepacket.h b/src/cdvframepacket.h
index 69917b7..cddad5d 100644
--- a/src/cdvframepacket.h
+++ b/src/cdvframepacket.h
@@ -55,6 +55,7 @@ public:
     CDvFramePacket();
     CDvFramePacket(const struct dstar_dvframe *, uint16, uint8);
     CDvFramePacket(const uint8 *, const uint8 *, uint16, uint8, uint8);
+    CDvFramePacket(const uint8 *, uint16, uint8, uint8, uint8);
     CDvFramePacket(uint16, uint8, const uint8 *, const uint8 *, uint8, uint8, const uint8 *, const uint8 *);
     CDvFramePacket(const CDvFramePacket &);
     
diff --git a/src/cdvheaderpacket.cpp b/src/cdvheaderpacket.cpp
index 0ee30d0..3a281b2 100644
--- a/src/cdvheaderpacket.cpp
+++ b/src/cdvheaderpacket.cpp
@@ -70,6 +70,22 @@ CDvHeaderPacket::CDvHeaderPacket(uint32 my, const CCallsign &ur, const CCallsign
     m_csMY = CCallsign("", my);
 }
 
+// YSF constructor
+
+CDvHeaderPacket::CDvHeaderPacket(const CCallsign &my, const CCallsign &ur, const CCallsign &rpt1, const CCallsign &rpt2, uint16 sid, uint8 pid)
+: CPacket(sid, pid, 0, 0)
+{
+    m_uiFlag1 = 0;
+    m_uiFlag2 = 0;
+    m_uiFlag3 = 0;
+    m_uiCrc = 0;
+    m_csUR = ur;
+    m_csRPT1 = rpt1;
+    m_csRPT2 = rpt2;
+    m_csMY = my;
+}
+
+
 // copy constructor
 
 CDvHeaderPacket::CDvHeaderPacket(const CDvHeaderPacket &Header)
diff --git a/src/cdvheaderpacket.h b/src/cdvheaderpacket.h
index 28cb771..df9eb79 100644
--- a/src/cdvheaderpacket.h
+++ b/src/cdvheaderpacket.h
@@ -63,7 +63,8 @@ public:
     CDvHeaderPacket();
     CDvHeaderPacket(const struct dstar_header *, uint16, uint8);
     CDvHeaderPacket(uint32, const CCallsign &, const CCallsign &, const CCallsign &, uint16, uint8, uint8);
-    CDvHeaderPacket(const CDvHeaderPacket &);
+    CDvHeaderPacket(const CCallsign &, const CCallsign &, const CCallsign &, const CCallsign &, uint16, uint8);
+   CDvHeaderPacket(const CDvHeaderPacket &);
     
     // destructor
     virtual ~CDvHeaderPacket(){};
diff --git a/src/cdvlastframepacket.cpp b/src/cdvlastframepacket.cpp
index 5908303..eb44f4d 100644
--- a/src/cdvlastframepacket.cpp
+++ b/src/cdvlastframepacket.cpp
@@ -57,6 +57,14 @@ CDvLastFramePacket::CDvLastFramePacket
 {
 }
 
+// ysf constructor
+
+CDvLastFramePacket::CDvLastFramePacket(const uint8 *ambe, uint16 sid, uint8 pid, uint8 spid, uint8 fid)
+    : CDvFramePacket(ambe, sid, pid, spid, fid)
+{
+}
+
+
 // copy constructor
     
 CDvLastFramePacket::CDvLastFramePacket(const CDvLastFramePacket &DvFrame)
diff --git a/src/cdvlastframepacket.h b/src/cdvlastframepacket.h
index 685e9d4..8dc339d 100644
--- a/src/cdvlastframepacket.h
+++ b/src/cdvlastframepacket.h
@@ -42,6 +42,7 @@ public:
     CDvLastFramePacket();
     CDvLastFramePacket(const struct dstar_dvframe *, uint16, uint8);
     CDvLastFramePacket(const uint8 *, const uint8 *, uint16, uint8, uint8);
+    CDvLastFramePacket(const uint8 *, uint16, uint8, uint8, uint8);
     CDvLastFramePacket(uint16, uint8, const uint8 *, const uint8 *, uint8, uint8, const uint8 *, const uint8 *);
     CDvLastFramePacket(const CDvLastFramePacket &);
     
diff --git a/src/cgatekeeper.cpp b/src/cgatekeeper.cpp
index fb2d0b0..8ec8ce1 100644
--- a/src/cgatekeeper.cpp
+++ b/src/cgatekeeper.cpp
@@ -101,6 +101,7 @@ bool CGateKeeper::MayLink(const CCallsign &callsign, const CIp &ip, int protocol
         case PROTOCOL_DCS:
         case PROTOCOL_DMRPLUS:
         case PROTOCOL_DMRMMDVM:
+        case PROTOCOL_YSF:
             // first check is IP & callsigned listed OK
             ok &= IsNodeListedOk(callsign, ip);
             // todo: then apply any protocol specific authorisation for the operation
@@ -141,6 +142,7 @@ bool CGateKeeper::MayTransmit(const CCallsign &callsign, const CIp &ip, int prot
         case PROTOCOL_DCS:
         case PROTOCOL_DMRPLUS:
         case PROTOCOL_DMRMMDVM:
+        case PROTOCOL_YSF:
             // first check is IP & callsigned listed OK
             ok &= IsNodeListedOk(callsign, ip, module);
             // todo: then apply any protocol specific authorisation for the operation
diff --git a/src/cgolay24128.cpp b/src/cgolay24128.cpp
new file mode 100644
index 0000000..d65c330
--- /dev/null
+++ b/src/cgolay24128.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 "cgolay24128.h"
+
+#include <cstdio>
+#include <cassert>
+
+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/src/cgolay24128.h b/src/cgolay24128.h
new file mode 100644
index 0000000..c8eb3c2
--- /dev/null
+++ b/src/cgolay24128.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/src/cpacket.cpp b/src/cpacket.cpp
index 02b8931..94bf645 100644
--- a/src/cpacket.cpp
+++ b/src/cpacket.cpp
@@ -35,36 +35,70 @@ CPacket::CPacket()
     m_uiStreamId = 0;
     m_uiDstarPacketId = 0;
     m_uiDmrPacketId = 0;
+    m_uiDmrPacketSubid = 0;
+    m_uiYsfPacketId = 0;
+    m_uiYsfPacketSubId = 0;
+    m_uiYsfPacketFrameId = 0;
     m_uiModuleId = ' ';
     m_uiOriginId = ORIGIN_LOCAL;
 };
 
+// dstar contrsuctor
+
 CPacket::CPacket(uint16 sid, uint8 dstarpid)
 {
     m_uiStreamId = sid;
     m_uiDstarPacketId = dstarpid;
     m_uiDmrPacketId = 0xFF;
     m_uiDmrPacketSubid  = 0xFF;
+    m_uiYsfPacketId = 0xFF;
+    m_uiYsfPacketSubId = 0xFF;
+    m_uiYsfPacketFrameId = 0xFF;
     m_uiModuleId = ' ';
     m_uiOriginId = ORIGIN_LOCAL;
 };
 
+// dmr constructor
+
 CPacket::CPacket(uint16 sid, uint8 dmrpid, uint8 dmrspid)
 {
     m_uiStreamId = sid;
     m_uiDmrPacketId = dmrpid;
     m_uiDmrPacketSubid = dmrspid;
     m_uiDstarPacketId = 0xFF;
+    m_uiYsfPacketId = 0xFF;
+    m_uiYsfPacketSubId = 0xFF;
+    m_uiYsfPacketFrameId = 0xFF;
     m_uiModuleId = ' ';
     m_uiOriginId = ORIGIN_LOCAL;
 };
 
-CPacket::CPacket(uint16 sid, uint8 dstarpid, uint8 dmrpid, uint8 dmrsubpid)
+// ysf constructor
+
+CPacket::CPacket(uint16 sid, uint8 ysfpid, uint8 ysfsubpid, uint8 ysffrid)
+{
+    m_uiStreamId = sid;
+    m_uiYsfPacketId = ysfpid;
+    m_uiYsfPacketSubId = ysfsubpid;
+    m_uiYsfPacketFrameId = ysffrid;
+    m_uiDstarPacketId = 0xFF;
+    m_uiDmrPacketId = 0xFF;
+    m_uiDmrPacketSubid = 0xFF;
+    m_uiModuleId = ' ';
+    m_uiOriginId = ORIGIN_LOCAL;
+}
+
+// xlx  constructor
+
+CPacket::CPacket(uint16 sid, uint8 dstarpid, uint8 dmrpid, uint8 dmrsubpid, uint8 ysfpid, uint8 ysfsubpid, uint8 ysffrid)
 {
     m_uiStreamId = sid;
     m_uiDstarPacketId = dstarpid;
     m_uiDmrPacketId = dmrpid;
     m_uiDmrPacketSubid  = dmrsubpid;
+    m_uiYsfPacketId = ysfpid;
+    m_uiYsfPacketSubId = ysfsubpid;
+    m_uiYsfPacketFrameId = ysffrid;
     m_uiModuleId = ' ';
     m_uiOriginId = ORIGIN_LOCAL;
 }
@@ -99,4 +133,11 @@ void CPacket::UpdatePids(uint32 pid)
         m_uiDmrPacketId = ((pid / 3) % 6);
         m_uiDmrPacketSubid = ((pid % 3) + 1);
     }
+    // ysf pids need update ?
+    if ( m_uiYsfPacketId == 0xFF )
+    {
+        m_uiYsfPacketId = ((pid / 5) % 8);
+        m_uiYsfPacketSubId = pid % 5;
+        m_uiYsfPacketFrameId = ((pid / 5) & 0x7FU) << 1;
+    }
 }
diff --git a/src/cpacket.h b/src/cpacket.h
index 30280b5..eddcd39 100644
--- a/src/cpacket.h
+++ b/src/cpacket.h
@@ -42,7 +42,8 @@ public:
     CPacket();
     CPacket(uint16 sid, uint8 dstarpid);
     CPacket(uint16 sid, uint8 dmrpid, uint8 dmrsubpid);
-    CPacket(uint16 sid, uint8 dstarpid, uint8 dmrpid, uint8 dmrsubpid);
+    CPacket(uint16 sid, uint8 ysfpid, uint8 ysfsubpid, uint8 ysfsubpidmax);
+    CPacket(uint16 sid, uint8 dstarpid, uint8 dmrpid, uint8 dmrsubpid, uint8 ysfpid, uint8 ysfsubpid, uint8 ysfsubpidmax);
     
     // destructor
     virtual ~CPacket() {};
@@ -63,6 +64,9 @@ public:
     uint8  GetDstarPacketId(void) const             { return m_uiDstarPacketId; }
     uint8  GetDmrPacketId(void) const               { return m_uiDmrPacketId; }
     uint8  GetDmrPacketSubid(void) const            { return m_uiDmrPacketSubid; }
+    uint8  GetYsfPacketId(void) const               { return m_uiYsfPacketId; }
+    uint8  GetYsfPacketSubId(void) const            { return m_uiYsfPacketSubId; }
+    uint8  GetYsfPacketFrameId(void) const          { return m_uiYsfPacketFrameId; }
     uint8  GetModuleId(void) const                  { return m_uiModuleId; }
     bool   IsLocalOrigin(void) const                { return (m_uiOriginId == ORIGIN_LOCAL); }
     
@@ -78,6 +82,9 @@ protected:
     uint8   m_uiDstarPacketId;
     uint8   m_uiDmrPacketId;
     uint8   m_uiDmrPacketSubid;
+    uint8   m_uiYsfPacketId;
+    uint8   m_uiYsfPacketSubId;
+    uint8   m_uiYsfPacketFrameId;
     uint8   m_uiModuleId;
     uint8   m_uiOriginId;
 };
diff --git a/src/cprotocol.h b/src/cprotocol.h
index 60ad0dc..1b43371 100644
--- a/src/cprotocol.h
+++ b/src/cprotocol.h
@@ -139,7 +139,7 @@ protected:
     CCallsign       m_ReflectorCallsign;
     
     // debug
-    CTimePoint          m_DebugTimer;
+    CTimePoint      m_DebugTimer;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/cprotocols.cpp b/src/cprotocols.cpp
index 53f5499..92b353f 100644
--- a/src/cprotocols.cpp
+++ b/src/cprotocols.cpp
@@ -29,6 +29,7 @@
 #include "cxlxprotocol.h"
 #include "cdmrplusprotocol.h"
 #include "cdmrmmdvmprotocol.h"
+#include "cysfprotocol.h"
 #include "cprotocols.h"
 
 
@@ -96,6 +97,11 @@ bool CProtocols::Init(void)
         delete m_Protocols[5];
         m_Protocols[5] = new CDmrmmdvmProtocol;
         ok &= m_Protocols[5]->Init();
+        
+        // create and initialize YSF
+        delete m_Protocols[6];
+        m_Protocols[6] = new CYsfProtocol;
+        ok &= m_Protocols[6]->Init();
     }
     m_Mutex.unlock();
    
diff --git a/src/creflector.cpp b/src/creflector.cpp
index ed6ba58..2eeea8b 100644
--- a/src/creflector.cpp
+++ b/src/creflector.cpp
@@ -29,6 +29,8 @@
 #include "cdmriddirfile.h"
 #include "cdmriddirhttp.h"
 #include "ctranscoder.h"
+#include "cysfnodedirfile.h"
+#include "cysfnodedirhttp.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////
 // constructor
@@ -43,7 +45,7 @@ CReflector::CReflector()
         m_RouterThreads[i] = NULL;
     }
 #ifdef DEBUG_DUMPFILE
-    m_DebugFile.open("/Users/jeanluc/Desktop/dmrdebug.txt");
+    m_DebugFile.open("/Users/jeanluc/Desktop/xlxdebug.txt");
 #endif
 }
 
@@ -105,6 +107,9 @@ bool CReflector::Start(void)
     // init dmrid directory
     g_DmridDir.Init();
     
+    // init wiresx node directory
+    g_YsfNodeDir.Init();
+    
     // init the transcoder
     g_Transcoder.Init();
     
@@ -173,6 +178,11 @@ void CReflector::Stop(void)
     
     // close gatekeeper
     g_GateKeeper.Close();
+    
+    // close databases
+    g_DmridDir.Close();
+    g_YsfNodeDir.Close();
+
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
@@ -389,7 +399,7 @@ void CReflector::XmlReportThread(CReflector *This)
             // and close file
             xmlFile.close();
         }
-#ifndef NO_ERROR_ON_XML_OPEN_FAIL
+#ifndef DEBUG_NO_ERROR_ON_XML_OPEN_FAIL
         else
         {
             std::cout << "Failed to open " << XML_PATH  << std::endl;
diff --git a/src/cwiresxcmd.cpp b/src/cwiresxcmd.cpp
new file mode 100644
index 0000000..e0d61a1
--- /dev/null
+++ b/src/cwiresxcmd.cpp
@@ -0,0 +1,54 @@
+//
+//  cwiresxcmd.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include "main.h"
+#include "cwiresxcmd.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructor
+
+CWiresxCmd::CWiresxCmd()
+{
+    m_iCmd = WIRESX_CMD_UNKNOWN;
+    m_Time.Now();
+}
+
+CWiresxCmd::CWiresxCmd(const CIp &Ip, const CCallsign &Callsign, int iCmd, int iArg)
+{
+    m_Ip = Ip;
+    m_Callsign = Callsign;
+    m_iCmd = iCmd;
+    m_iArg = iArg;
+    m_Time.Now();
+}
+
+CWiresxCmd::CWiresxCmd(const CWiresxCmd &Cmd)
+{
+    m_Ip = Cmd.m_Ip;
+    m_Callsign = Cmd.m_Callsign;
+    m_iCmd = Cmd.m_iCmd;
+    m_iArg = Cmd.m_iArg;
+    m_Time = Cmd.m_Time;
+}
diff --git a/src/cwiresxcmd.h b/src/cwiresxcmd.h
new file mode 100644
index 0000000..29628b1
--- /dev/null
+++ b/src/cwiresxcmd.h
@@ -0,0 +1,75 @@
+//
+//  cwiresxcmd.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+
+#ifndef cwiresxcmd_h
+#define cwiresxcmd_h
+
+#include "ccallsign.h"
+#include "cip.h"
+#include "ctimepoint.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// defines
+
+// Wires-X commands
+#define WIRESX_CMD_UNKNOWN          0
+#define WIRESX_CMD_DX_REQ           1
+#define WIRESX_CMD_ALL_REQ          2
+#define WIRESX_CMD_SEARCH_REQ       3
+#define WIRESX_CMD_CONN_REQ         4
+#define WIRESX_CMD_DISC_REQ         5
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CWiresxCmd
+{
+public:
+    // constructor
+    CWiresxCmd();
+    CWiresxCmd(const CIp &, const CCallsign &, int, int);
+    CWiresxCmd(const CWiresxCmd &);
+    
+    // destructor
+    virtual ~CWiresxCmd() {}
+    
+    // get
+    const CCallsign &GetCallsign(void) const        { return m_Callsign; }
+    const CIp &GetIp(void) const                    { return m_Ip; }
+    int   GetCmd(void) const                        { return m_iCmd; }
+    int   GetArg(void) const                        { return m_iArg; }
+    const CTimePoint &GetTime(void) const           { return m_Time; }
+    
+protected:
+    // data
+    CIp         m_Ip;
+    CCallsign   m_Callsign;
+    int         m_iCmd;
+    int         m_iArg;
+    CTimePoint  m_Time;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cwiresxcmd_h */
diff --git a/src/cwiresxcmdhandler.cpp b/src/cwiresxcmdhandler.cpp
new file mode 100644
index 0000000..b1f272a
--- /dev/null
+++ b/src/cwiresxcmdhandler.cpp
@@ -0,0 +1,774 @@
+//
+//  cwiresxcmdhandler.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include <string.h>
+#include "main.h"
+#include "ccrc.h"
+#include "cysffich.h"
+#include "cysfpayload.h"
+#include "cysfclient.h"
+#include "cysfnodedirfile.h"
+#include "cysfnodedirhttp.h"
+#include "cysfutils.h"
+#include "creflector.h"
+#include "cwiresxcmdhandler.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructor
+
+CWiresxCmdHandler::CWiresxCmdHandler()
+{
+    m_seqNo = 0;
+    m_bStopThread = false;
+    m_pThread = NULL;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// destructor
+
+CWiresxCmdHandler::~CWiresxCmdHandler()
+{
+    // kill threads
+    m_bStopThread = true;
+    if ( m_pThread != NULL )
+    {
+        m_pThread->join();
+        delete m_pThread;
+    }
+    
+    // empty queue
+    m_CmdQueue.Lock();
+    while ( !m_CmdQueue.empty() )
+    {
+        m_CmdQueue.pop();
+    }
+    m_CmdQueue.Unlock();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// initialization
+
+bool CWiresxCmdHandler::Init(void)
+{
+    // fill our wiresx info
+    m_ReflectorWiresxInfo.SetCallsign(g_Reflector.GetCallsign());
+    m_ReflectorWiresxInfo.SetNode(g_Reflector.GetCallsign());
+    m_ReflectorWiresxInfo.SetName("Reflector");
+
+    // reset stop flag
+    m_bStopThread = false;
+
+    // start  thread;
+    m_pThread = new std::thread(CWiresxCmdHandler::Thread, this);
+    
+    // done
+    return true;
+}
+
+void CWiresxCmdHandler::Close(void)
+{
+    m_bStopThread = true;
+    if ( m_pThread != NULL )
+    {
+        m_pThread->join();
+        delete m_pThread;
+        m_pThread = NULL;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// thread
+
+void CWiresxCmdHandler::Thread(CWiresxCmdHandler *This)
+{
+    while ( !This->m_bStopThread )
+    {
+        This->Task();
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// task
+
+void CWiresxCmdHandler::Task(void)
+{
+    CWiresxInfo Info;
+    CWiresxCmd  Cmd;
+    uint32  uiNodeTxFreq;
+    uint32  uiNodeRxFreq;
+    char cModule;
+    bool bCmd;
+    
+    // anything to do ?
+    bCmd = false;
+    m_CmdQueue.Lock();
+    {
+        // any cmd in our queue ?
+        if ( !m_CmdQueue.empty() )
+        {
+            // yes, get the command
+            Cmd = m_CmdQueue.front();
+            // check that the command is at least one second old
+            // so that the so delayed processing of the command
+            // introduce the delay the radio needs to switch
+            // from tx to rx
+            if ( Cmd.GetTime().DurationSinceNow() >= WIRESX_REPLY_DELAY )
+            {
+                m_CmdQueue.pop();
+                bCmd = true;
+            }
+        }
+    }
+    m_CmdQueue.Unlock();
+    
+    
+    // handle it
+    if ( bCmd )
+    {
+        // fill our info object
+        Info = m_ReflectorWiresxInfo;
+        g_YsfNodeDir.FindFrequencies(Cmd.GetCallsign(), &uiNodeTxFreq, &uiNodeRxFreq);
+        Info.SetFrequencies(uiNodeTxFreq, uiNodeRxFreq);
+
+        // find our client and the module it's currentlink linked to
+        cModule = ' ';
+        CClients *clients = g_Reflector.GetClients();
+        CClient *client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), PROTOCOL_YSF);
+        if ( client != NULL )
+        {
+            cModule = client->GetReflectorModule();
+        }
+        g_Reflector.ReleaseClients();
+        
+        // and crack the cmd
+        switch ( Cmd.GetCmd() )
+        {
+            case WIRESX_CMD_DX_REQ:
+                std::cout << "Wires-X DX_REQ command from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
+                // reply
+                ReplyToWiresxDxReqPacket(Cmd.GetIp(), Info, cModule);
+                break;
+            case WIRESX_CMD_ALL_REQ:
+            case WIRESX_CMD_SEARCH_REQ:
+                std::cout << "Wires-X ALL_REQ command from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
+                // reply
+                ReplyToWiresxAllReqPacket(Cmd.GetIp(), Info, Cmd.GetArg());
+                break;
+            case WIRESX_CMD_CONN_REQ:
+                if ( (Cmd.GetArg() >= 1) && (Cmd.GetArg() <= NB_OF_MODULES) )
+                {
+                    cModule = 'A' + (char)(Cmd.GetArg() - 1);
+                    std::cout << "Wires-X CONN_REQ command to link on module " << cModule << " from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
+                    // acknowledge
+                    ReplyToWiresxConnReqPacket(Cmd.GetIp(), Info, cModule);
+                    // change client's module
+                    CClients *clients = g_Reflector.GetClients();
+                    CClient *client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), PROTOCOL_YSF);
+                    if ( client != NULL )
+                    {
+                        client->SetReflectorModule(cModule);
+                    }
+                    g_Reflector.ReleaseClients();
+                }
+                else
+                {
+                    std::cout << "Wires-X CONN_REQ command with illegal argument from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
+                }
+                break;
+            case WIRESX_CMD_DISC_REQ:
+                std::cout << "Wires-X DISC_REQ command from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
+                // and reply
+                ReplyToWiresxDiscReqPacket(Cmd.GetIp(), Info);
+                // change client's module
+                {
+                    CClients *clients = g_Reflector.GetClients();
+                    CClient *client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), PROTOCOL_YSF);
+                    if ( client != NULL )
+                    {
+                        client->SetReflectorModule(' ');
+                    }
+                    g_Reflector.ReleaseClients();
+                }
+                    break;
+            case WIRESX_CMD_UNKNOWN:
+            default:
+                std::cout << "Wires-X non implemented command from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
+                break;
+        }
+    }
+    else
+    {
+        // if nothing to do, sleep a bit
+        CTimePoint::TaskSleepFor(10);
+    }
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// packet encoding
+
+bool CWiresxCmdHandler::ReplyToWiresxDxReqPacket(const CIp &Ip, const CWiresxInfo &WiresxInfo, char Module)
+{
+    uint8 DX_RESP[] = {0x5DU, 0x51U, 0x5FU, 0x26U};
+    bool ok;
+    uint8 data[150U];
+    uint8 RoomId;
+    bool IsLinked;
+    
+    // linked module
+    // module A == 0
+    IsLinked = (Module != ' ');
+    RoomId = (uint8)(Module - 'A');
+    
+    // fill data buffer
+    ::memset(data, 0x00U, 150U);
+    ::memset(data, ' ', 128U);
+    // seq no
+    data[0U] = m_seqNo;
+    // command
+    ::memcpy(data +  1U, DX_RESP, 4U);
+    // node info
+    ::memcpy(data +  5U, WiresxInfo.GetId(), 5U);
+    ::memcpy(data + 10U, WiresxInfo.GetNode(), 10U);
+    ::memcpy(data + 20U, WiresxInfo.GetName(), 14U);
+    // linked room
+    if (!IsLinked)
+    {
+        data[34U] = '1';
+        data[35U] = '2';
+        // no room linked
+        data[57U] = '0';
+        data[58U] = '0';
+        data[59U] = '0';
+    }
+    else
+    {
+        data[34U] = '1';
+        data[35U] = '5';
+        // linked room
+        char item[16U];
+        // refl->m_id
+        ::sprintf(item, "%05d", 4001U + RoomId);
+        ::memcpy(data + 36U, item, 5U);
+        // refl->name
+        ::memset(item, ' ', 16U);
+        ::memcpy(item, "Module", 6U);
+        item[7] = 'A' + RoomId;
+        ::memcpy(data + 41U, item, 16U);
+        // refl->count
+        ::sprintf(item, "%03d", RoomId + 1);
+        ::memcpy(data + 57U, item, 3U);
+        // other
+        ::memset(data + 60U, ' ', 10U);
+        // refl->m_desc
+        ::memcpy(data + 70U, "Description   ", 14U);
+    }
+
+    // frequencies
+    {
+        unsigned int offset;
+        char sign;
+        if (WiresxInfo.GetTxFrequency() >= WiresxInfo.GetRxFrequency())
+        {
+            offset = WiresxInfo.GetTxFrequency() - WiresxInfo.GetRxFrequency();
+            sign = '-';
+        }
+        else
+        {
+            offset = WiresxInfo.GetRxFrequency() - WiresxInfo.GetTxFrequency();
+            sign = '+';
+        }
+        unsigned int freqHz = WiresxInfo.GetTxFrequency() % 1000000U;
+        unsigned int freqkHz = (freqHz + 500U) / 1000U;
+
+        char freq[30U];
+        ::sprintf(freq, "%05u.%03u000%c%03u.%06u",
+               WiresxInfo.GetTxFrequency() / 1000000U,
+               freqkHz, sign, offset / 1000000U, offset % 1000000U);
+        
+        ::memcpy(data + 84U, freq, 23U);
+    }
+
+    // EOD & CRC
+    data[127U] = 0x03U;
+    data[128U] = CCRC::addCRC(data, 128U);
+
+    // and encode the reply
+    CBuffer Data;
+    Data.Set(data, 129U);
+    ok = EncodeAndSendWiresxPacket(Ip, Data, WiresxInfo);
+
+    // done
+    m_seqNo++;
+    return ok;
+}
+
+bool CWiresxCmdHandler::ReplyToWiresxAllReqPacket(const CIp &Ip, const CWiresxInfo &WiresxInfo, int Start)
+{
+    bool ok = false;
+    uint8 ALL_RESP[]  = {0x5DU, 0x46U, 0x5FU, 0x29U};
+    uint8 data[1100U];
+    
+    // fill data buffer
+    ::memset(data, 0x00U, 1100U);
+    // seq no
+    data[0U] = m_seqNo;
+    // command
+    ::memcpy(data + 1U, ALL_RESP, 4U);
+    data[5U] = '2';
+    data[6U] = '1';
+    // node info
+    ::memcpy(data +  7U, WiresxInfo.GetId(), 5U);
+    ::memcpy(data + 12U, WiresxInfo.GetNode(), 10U);
+
+    // number of entries
+    uint total = NB_OF_MODULES;
+    uint n = NB_OF_MODULES - Start;
+    if (n > 20U)
+        n = 20U;
+    ::sprintf((char*)(data + 22U), "%03u%03u", n, total);
+    data[28U] = 0x0DU;
+
+    // entries
+    uint offset = 29U;
+    for ( uint i = 0; i < n; i++ )
+    {
+        char item[16U];
+        // module A == 0
+        int RoomId = i + Start;
+        
+        // prepare
+        ::memset(data + offset, ' ', 50U);
+        data[offset + 0U] = '5';
+
+        // refl->m_id
+        ::sprintf(item, "%05d", 4001U + RoomId);
+        ::memcpy(data + offset + 1U, item, 5U);
+        // refl->name
+        ::memset(item, ' ', 16U);
+        ::memcpy(item, "Module", 6U);
+        item[7] = 'A' + RoomId;
+        ::memcpy(data + offset + 6U, item, 16U);
+        // refl->count
+        ::sprintf(item, "%03d", RoomId + 1);
+        ::memcpy(data + offset + 22U, item, 3U);
+        // other
+        ::memset(data + offset + 25U, ' ', 10U);
+        // refl->m_desc
+        ::memcpy(data + offset + 35U, "Description   ", 14U);
+        data[offset + 49U] = 0x0DU;
+        // next
+        offset += 50U;
+    }
+
+    // the following is a workaround for FT2D which
+    // do not accept less than 20 items frames.
+    // first send a 'patched' frame
+    if ( n < 20 )
+    {
+        // FT2D workaround
+        uint offset2 = offset;
+        // patch the remaining
+        uint k = 1029U - offset2;
+        ::memset(data+offset2, ' ', k);
+        offset2 += k;
+        
+        // EOD + CRC
+        data[offset2 + 0U] = 0x03U;
+        data[offset2 + 1U] = CCRC::addCRC(data, offset2 + 1U);
+        offset2 += 2U;
+        
+        // and encode the reply
+        CBuffer Data;
+        Data.Set(data, offset2 + 2U);
+        ok = EncodeAndSendWiresxPacket(Ip, Data, WiresxInfo);
+    }
+    
+
+    // and next repeat with normal frame
+    {
+        // EOD + CRC
+        data[offset + 0U] = 0x03U;
+        data[offset + 1U] = CCRC::addCRC(data, offset + 1U);
+        offset += 2U;
+
+        // patch the remaining
+        //uint k = 1031U - offset;
+        //::memset(data+offset, ' ', k);
+        //offset += k;
+        
+        // and encode the reply
+        CBuffer Data;
+        Data.Set(data, offset + 2U);
+        ok = EncodeAndSendWiresxPacket(Ip, Data, WiresxInfo);
+    }
+
+
+    // done
+    m_seqNo++;
+    return ok;
+}
+
+bool CWiresxCmdHandler::ReplyToWiresxConnReqPacket(const CIp &Ip, const CWiresxInfo &WiresxInfo, char Module)
+{
+    uint8 CONN_RESP[] = {0x5DU, 0x41U, 0x5FU, 0x26U};
+    bool ok = false;
+    uint8 data[110U];
+    uint RoomId;
+
+    // linked room
+    // Module A == 0
+    RoomId = (uint8)(Module - 'A');
+    
+    // prepare buffer
+    ::memset(data, 0x00U, 110U);
+    ::memset(data, ' ', 90U);
+    
+    // seq no
+    data[0U] = m_seqNo;
+    // command
+    ::memcpy(data + 1U, CONN_RESP, 4U);
+    // node info
+    ::memcpy(data +  5U, WiresxInfo.GetId(), 5U);
+    ::memcpy(data + 10U, WiresxInfo.GetNode(), 10U);
+    ::memcpy(data + 20U, WiresxInfo.GetName(), 14U);
+    data[34U] = '1';
+    data[35U] = '5';
+    // entry info
+    {
+        char item[16U];
+
+        // refl->m_id
+        ::sprintf(item, "%05d", 4001U + RoomId);
+        ::memcpy(data + 36U, item, 5U);
+        // refl->name
+        ::memset(item, ' ', 16U);
+        ::memcpy(item, "Module", 6U);
+        item[7] = 'A' + RoomId;
+        ::memcpy(data + 41U, item, 16U);
+        // refl->count
+        ::sprintf(item, "%03d", RoomId + 1);
+        ::memcpy(data + 57U, item, 3U);
+        // refl->m_desc
+        ::memcpy(data + 70U, "Description   ", 14U);
+    }
+    data[84U] = '0';
+    data[85U] = '0';
+    data[86U] = '0';
+    data[87U] = '0';
+    data[88U] = '0';
+
+    // EOD + CRC
+    data[89U] = 0x03U;
+    data[90U] = CCRC::addCRC(data, 90U);
+
+    // and encode the reply
+    CBuffer Data;
+    Data.Set(data, 91U);
+    ok = EncodeAndSendWiresxPacket(Ip, Data, WiresxInfo);
+
+    // done
+    m_seqNo++;
+    return ok;
+}
+
+bool CWiresxCmdHandler::ReplyToWiresxDiscReqPacket(const CIp &Ip, const CWiresxInfo &WiresxInfo)
+{
+    uint8 DISC_RESP[] = {0x5DU, 0x41U, 0x5FU, 0x26U};
+    bool ok = false;
+    uint8 data[110U];
+    
+    // prepare buffer
+    ::memset(data, 0x00U, 110U);
+    ::memset(data, ' ', 90U);
+    
+    // seq no
+    data[0U] = m_seqNo;
+    // command
+    ::memcpy(data + 1U, DISC_RESP, 4U);
+    // node info
+    ::memcpy(data +  5U, WiresxInfo.GetId(), 5U);
+    ::memcpy(data + 10U, WiresxInfo.GetNode(), 10U);
+    ::memcpy(data + 20U, WiresxInfo.GetName(), 14U);
+    // data
+    data[34U] = '1';
+    data[35U] = '2';
+
+    data[57U] = '0';
+    data[58U] = '0';
+    data[59U] = '0';
+
+    // EOD + CRC
+    data[89U] = 0x03U;
+    data[90U] = CCRC::addCRC(data, 90U);
+
+    // and encode the reply
+    CBuffer Data;
+    Data.Set(data, 91U);
+    ok = EncodeAndSendWiresxPacket(Ip, Data, WiresxInfo);
+
+    // done
+    m_seqNo++;
+    return ok;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+///// packet encoding helpers
+
+bool CWiresxCmdHandler::EncodeAndSendWiresxPacket(const CIp &Ip, const CBuffer &DataOrg, const CWiresxInfo &WiresxInfo)
+{
+    uint8 DEFAULT_FICH[] = {0x20U, 0x00U, 0x01U, 0x00U};
+    uint8 NET_HEADER[] = "YSFD                    ALL      ";
+    CYSFFICH fich;
+    CYSFPayload payload;
+    uint8 buffer[200U];
+
+    
+    CBuffer Data(DataOrg);
+    
+    // seq no
+    uint8 seqNo = 0U;
+    
+    // calculate bt and adjust length
+    uint length = (uint)Data.size();
+    uint8 bt = 0;
+    if (length > 260U)
+    {
+        bt = 1U;
+        bt += (length - 260U) / 259U;
+        length += bt;
+    }
+    if (length > 20U)
+    {
+        uint blocks = (length - 20U) / 40U;
+        if ((length % 40U) > 0U)
+            blocks++;
+        length = blocks * 40U + 20U;
+    }
+    else
+    {
+        length = 20U;
+    }
+    if ( length > (uint)Data.size() )
+    {
+        Data.Append((uint8)0x20U, (int)(length - (uint)Data.size()));
+    }
+    
+    // ft
+    uint8 ft = WiresxCalcFt(length, 0U);
+    
+    // Write the header
+    {
+        //header
+        ::memcpy(buffer, NET_HEADER, 34U);
+        ::memcpy(buffer + 4U, WiresxInfo.GetCallsign(), 10U);
+        ::memcpy(buffer + 14U, WiresxInfo.GetNode(), 10U);
+        // sync
+        ::memcpy(buffer + 35U, YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES);
+        // Fich
+        fich.load(DEFAULT_FICH);
+        fich.setFI(YSF_FI_HEADER);
+        fich.setBT(bt);
+        fich.setFT(ft);
+        fich.encode(buffer + 35U + 5U);
+        // payload
+        payload.writeDataFRModeData1(WiresxInfo.GetCsd1(), buffer + 35U);
+        payload.writeDataFRModeData2(WiresxInfo.GetCsd2(), buffer + 35U);
+        // seqno
+        buffer[34U] = seqNo;
+        seqNo += 2U;
+        // and post it
+        SendPacket(Ip, buffer);
+    }
+
+    // write the payload
+    fich.setFI(YSF_FI_COMMUNICATIONS);
+    uint offset = 0;
+    for ( uint8 bn = 0; bn <= bt; bn++ )
+    {
+        for ( uint8 fn = 0; fn <= ft; fn++ )
+        {
+            // fich
+            fich.setFT(ft);
+            fich.setFN(fn);
+            fich.setBT(bt);
+            fich.setBN(bn);
+            fich.encode(buffer + 35U + 5U);
+            // seq no
+            buffer[34U] = seqNo;
+            seqNo += 2U;
+            // data
+            //if ( (bn == 0) && (fn == 0) )
+            if ( fn == 0 )
+            {
+                payload.writeDataFRModeData1(WiresxInfo.GetCsd1(), buffer + 35);
+                payload.writeDataFRModeData2(WiresxInfo.GetCsd2(), buffer + 35);
+            }
+            //else if ( (bn == 0) && (fn == 1) )
+            else if ( fn == 1 )
+            {
+                if ( bn == 0 )
+                {
+                    payload.writeDataFRModeData1(WiresxInfo.GetCsd3(), buffer + 35);
+                    payload.writeDataFRModeData2(Data.data() + offset, buffer + 35);
+                    offset += 20;
+                }
+                else
+                {
+                   uint8 temp[20U];
+                   temp[0U] = 0x00U;
+                   ::memcpy(temp + 1U, Data.data() + offset, 19U);
+                   payload.writeDataFRModeData2(temp, buffer + 35U);
+                   offset += 19U;
+                }
+            }
+            else
+            {
+                payload.writeDataFRModeData1(Data.data() + offset, buffer + 35);
+                offset += 20;
+                payload.writeDataFRModeData2(Data.data() + offset, buffer + 35);
+                offset += 20;
+            }
+            // and post it
+            SendPacket(Ip, buffer);
+            // and some delay before next packet
+            CTimePoint::TaskSleepFor(100);
+        }
+    }
+
+    // Write the trailer
+    {
+        // fich
+        fich.setFI(YSF_FI_TERMINATOR);
+        fich.setFN(ft);
+        fich.setBN(bt);
+        fich.encode(buffer + 35U + 5U);
+        // payload
+        payload.writeDataFRModeData1(WiresxInfo.GetCsd1(), buffer + 35U);
+        payload.writeDataFRModeData2(WiresxInfo.GetCsd2(), buffer + 35U);
+        // seq no
+        buffer[34U] = seqNo | 0x01U;
+        // and post it
+        SendPacket(Ip, buffer);
+    }
+    
+    // done
+    return true;
+}
+
+
+uint8 CWiresxCmdHandler::WiresxCalcFt(uint length, uint offset) const
+{
+    length -= offset;
+    if (length > 220U) return 7U;
+    if (length > 180U) return 6U;
+    if (length > 140U) return 5U;
+    if (length > 100U) return 4U;
+    if (length > 60U)  return 3U;
+    if (length > 20U)  return 2U;
+    return 1U;
+}
+
+
+void CWiresxCmdHandler::SendPacket(const CIp &Ip, uint8 *Buffer)
+{
+    //CBuffer packet(Buffer, 155);
+    //DebugTestDecodePacket(packet);
+
+    // and push in queue
+    m_PacketQueue.Lock();
+    {
+        m_PacketQueue.push(CWiresxPacket(CBuffer(Buffer, 155), Ip));
+    }
+    m_PacketQueue.Unlock();
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// debug
+
+#ifdef DEBUG_DUMPFILE
+bool CWiresxCmdHandler::DebugTestDecodePacket(const CBuffer &Buffer)
+{
+    uint8 tag[] = { 'Y','S','F','D' };
+    static uint8 command[4098];
+    static int len;
+    CYSFFICH Fich;
+    CYSFPayload payload;
+    CBuffer dump;
+    bool valid = false;
+    
+    if ( (Buffer.size() == 155) && (Buffer.Compare(tag, sizeof(tag)) == 0) )
+    {
+        // decode YSH fich
+        if ( Fich.decode(&(Buffer.data()[40])) )
+        {
+            std::cout << (int)Fich.getDT() << ","
+                      << (int)Fich.getFI() << ","
+                      << (int)Fich.getBN() << ","
+                      << (int)Fich.getBT() << ","
+                      << (int)Fich.getFN() << ","
+                      << (int)Fich.getFT() << " : ";
+            
+            switch ( Fich.getFI() )
+            {
+                case YSF_FI_HEADER:
+                    len = 0;
+                    ::memset(command, 0x00, sizeof(command));
+                    std::cout << "Header" << std::endl;
+                    break;
+                case YSF_FI_TERMINATOR:
+                    std::cout << "Trailer" << std::endl;
+                    std::cout << "length of payload : " << len << std::endl;
+                    dump.Set(command, len);
+                    dump.DebugDump(g_Reflector.m_DebugFile);
+                    dump.DebugDumpAscii(g_Reflector.m_DebugFile);
+                    break;
+                case YSF_FI_COMMUNICATIONS:
+                    if ( Fich.getDT() == YSF_DT_DATA_FR_MODE )
+                    {
+                        valid = payload.readDataFRModeData1(&(Buffer.data()[35]), command + len);
+                        len += 20;
+                        valid &= payload.readDataFRModeData2(&(Buffer.data()[35]), command + len);
+                        len += 20;
+                        std::cout << "decoded ok" << std::endl;
+                    }
+                    break;
+            }
+        }
+        else
+        {
+            std::cout << "invalid fich in packet" << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << "invalid size packet" << std::endl;
+    }
+    return valid;
+}
+#endif
diff --git a/src/cwiresxcmdhandler.h b/src/cwiresxcmdhandler.h
new file mode 100644
index 0000000..3a3b7a3
--- /dev/null
+++ b/src/cwiresxcmdhandler.h
@@ -0,0 +1,94 @@
+//
+//  cwiresxcmdhandler.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cwiresxcmdhandler_h
+#define cwiresxcmdhandler_h
+
+#include "cwiresxinfo.h"
+#include "cwiresxcmdqueue.h"
+#include "cwiresxpacketqueue.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+#define WIRESX_REPLY_DELAY  (1.000)
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CWiresxCmdHandler
+{
+public:
+    // constructor
+    CWiresxCmdHandler();
+    
+    // destructor
+    virtual ~CWiresxCmdHandler();
+    
+    // initialization
+    virtual bool Init(void);
+    virtual void Close(void);
+
+    // queues
+    CWiresxCmdQueue *GetCmdQueue(void)          { m_CmdQueue.Lock(); return &m_CmdQueue; }
+    void ReleaseCmdQueue(void)                  { m_CmdQueue.Unlock(); }
+    CWiresxPacketQueue *GetPacketQueue(void)    { m_PacketQueue.Lock(); return &m_PacketQueue; }
+    void ReleasePacketQueue(void)               { m_PacketQueue.Unlock(); }
+
+    // get
+    
+    // task
+    static void Thread(CWiresxCmdHandler *);
+    virtual void Task(void);
+    
+protected:
+    // packet encoding
+    bool ReplyToWiresxDxReqPacket(const CIp &, const CWiresxInfo &, char);
+    bool ReplyToWiresxAllReqPacket(const CIp &, const CWiresxInfo &, int);
+    bool ReplyToWiresxConnReqPacket(const CIp &, const CWiresxInfo &, char);
+    bool ReplyToWiresxDiscReqPacket(const CIp &, const CWiresxInfo &);
+    
+    // packet encoding helpers
+    bool EncodeAndSendWiresxPacket(const CIp &, const CBuffer &, const CWiresxInfo &);
+    uint8 WiresxCalcFt(uint, uint) const;
+    void SendPacket(const CIp &, uint8 *);
+
+    // debug
+    bool DebugTestDecodePacket(const CBuffer &);
+
+protected:
+    // data
+    CWiresxInfo        m_ReflectorWiresxInfo;
+    uint8_t            m_seqNo;
+    
+    // queues
+    CWiresxCmdQueue    m_CmdQueue;
+    CWiresxPacketQueue m_PacketQueue;
+    
+    // thread
+    bool               m_bStopThread;
+    std::thread        *m_pThread;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cwiresxcmdhandler_h */
diff --git a/src/cwiresxcmdqueue.h b/src/cwiresxcmdqueue.h
new file mode 100644
index 0000000..ae40a87
--- /dev/null
+++ b/src/cwiresxcmdqueue.h
@@ -0,0 +1,55 @@
+//
+//  cwiresxcmdqueue.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cwiresxcmdqueue_h
+#define cwiresxcmdqueue_h
+
+
+#include "cwiresxcmd.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CWiresxCmdQueue : public std::queue<CWiresxCmd>
+{
+public:
+    // constructor
+    CWiresxCmdQueue() {};
+    
+    // destructor
+    ~CWiresxCmdQueue() {};
+    
+    // lock
+    void Lock()                 { m_Mutex.lock(); }
+    void Unlock()               { m_Mutex.unlock(); }
+    
+protected:
+    // status
+    std::mutex  m_Mutex;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cwiresxcmdqueue_h */
diff --git a/src/cwiresxinfo.cpp b/src/cwiresxinfo.cpp
new file mode 100644
index 0000000..b2aacc8
--- /dev/null
+++ b/src/cwiresxinfo.cpp
@@ -0,0 +1,107 @@
+//
+//  cwiresxinfo.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 29/09/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include <string.h>
+#include "main.h"
+#include "ccallsign.h"
+#include "cwiresxinfo.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructor
+
+CWiresxInfo::CWiresxInfo()
+{
+    ::memset(m_callsign, ' ', YSF_CALLSIGN_LENGTH);
+    ::memset(m_node, ' ', YSF_CALLSIGN_LENGTH);
+    ::memset(m_name, ' ', 14);
+    ::memset(m_id, ' ', 6);
+    m_txFrequency = 0U;
+    m_rxFrequency = 0U;
+ 
+    ::memset(m_csd1, '*', 20U);
+    ::memset(m_csd2, ' ', 20U);
+    ::memset(m_csd3, ' ', 20U);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+///// set
+
+void CWiresxInfo::SetCallsign(const CCallsign &callsign)
+{
+    ::memset(m_callsign, ' ', YSF_CALLSIGN_LENGTH);
+    callsign.GetCallsign(m_callsign);
+    UpdateCsds();
+}
+
+void CWiresxInfo::SetNode(const char *node)
+{
+    ::memset(m_node, ' ', YSF_CALLSIGN_LENGTH);
+    ::memcpy(m_node, node, MIN(::strlen(node), YSF_CALLSIGN_LENGTH));
+    UpdateCsds();
+}
+
+void CWiresxInfo::SetName(const char *name)
+{
+    ::memset(m_name, ' ', 14);
+    ::memcpy(m_name, name, MIN(::strlen(name), 14));
+    UpdateId();
+}
+
+void CWiresxInfo::SetFrequencies(uint txFreq, uint rxFreq)
+{
+    m_txFrequency = txFreq;
+    m_rxFrequency = rxFreq;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// updates
+
+void CWiresxInfo::UpdateCsds(void)
+{
+    ::memset(m_csd1, '*', 20U);
+    ::memset(m_csd2, ' ', 20U);
+    ::memset(m_csd3, ' ', 20U);
+    ::memcpy(m_csd1 + 10U, m_node, 10U);
+    ::memcpy(m_csd2 +  0U, m_callsign, 10U);
+    ::memcpy(m_csd3 +  0U, m_id, 5U);
+    ::memcpy(m_csd3 + 15U, m_id, 5U);
+}
+
+void CWiresxInfo::UpdateId(void)
+{
+    uint hash = 0U;
+    for (uint i = 0U; i < 14; i++)
+    {
+        hash += m_name[i];
+        hash += (hash << 10);
+        hash ^= (hash >> 6);
+    }
+    hash += (hash << 3);
+    hash ^= (hash >> 11);
+    hash += (hash << 15);
+    ::sprintf((char *)m_id, "%05u", hash % 100000U);
+    UpdateCsds();
+}
diff --git a/src/cwiresxinfo.h b/src/cwiresxinfo.h
new file mode 100644
index 0000000..18207ef
--- /dev/null
+++ b/src/cwiresxinfo.h
@@ -0,0 +1,76 @@
+//
+//  cwiresxinfo.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 29/09/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cwiresxinfo_h
+#define cwiresxinfo_h
+
+#include "ysfdefines.h"
+#include "ccallsign.h"
+
+class CWiresxInfo
+{
+public:
+    // constructor
+    CWiresxInfo();
+    
+    // destructor
+    virtual ~CWiresxInfo() {}
+    
+    // get
+    const uint8 *GetCallsign(void) const    { return m_callsign; }
+    const uint8 *GetNode(void) const        { return m_node; }
+    const uint8 *GetName(void) const        { return m_name; }
+    const uint8 *GetId(void) const          { return m_id; }
+    uint        GetTxFrequency(void) const  { return m_txFrequency; }
+    uint        GetRxFrequency(void) const  { return m_rxFrequency; }
+    const uint8 *GetCsd1(void) const        { return m_csd1; }
+    const uint8 *GetCsd2(void) const        { return m_csd2; }
+    const uint8 *GetCsd3(void) const        { return m_csd3; }
+    
+    // set
+    void SetCallsign(const CCallsign &);
+    void SetNode(const char *);
+    void SetName(const char *);
+    void SetFrequencies(uint, uint);
+    
+    // uodates
+    void UpdateCsds(void);
+    void UpdateId(void);
+    
+protected:
+    // data
+    uint8 m_callsign[YSF_CALLSIGN_LENGTH];
+    uint8 m_node[YSF_CALLSIGN_LENGTH];
+    uint8 m_name[14];
+    uint8 m_id[6];
+    uint  m_txFrequency;
+    uint  m_rxFrequency;
+
+    uint8 m_csd1[20];
+    uint8 m_csd2[20];
+    uint8 m_csd3[20];
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cwiresxinfo_h */
diff --git a/src/cwiresxpacket.h b/src/cwiresxpacket.h
new file mode 100644
index 0000000..6e9f44b
--- /dev/null
+++ b/src/cwiresxpacket.h
@@ -0,0 +1,55 @@
+//
+//  cwiresxpacket.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cwiresxpacket_h
+#define cwiresxpacket_h
+
+#include "cbuffer.h"
+#include "cip.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CWiresxPacket
+{
+public:
+    // constructor
+    CWiresxPacket() {}
+    CWiresxPacket(const CBuffer &Buffer, const CIp &Ip) { m_Buffer = Buffer; m_Ip = Ip; }
+    
+    // destructor
+    virtual ~CWiresxPacket() {}
+    
+    // get
+    const CBuffer &GetBuffer(void) const        { return m_Buffer; }
+    const CIp &GetIp(void) const                { return m_Ip; }
+    
+protected:
+    // data
+    CBuffer     m_Buffer;
+    CIp         m_Ip;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cwiresxpacket_h */
diff --git a/src/cwiresxpacketqueue.h b/src/cwiresxpacketqueue.h
new file mode 100644
index 0000000..415a504
--- /dev/null
+++ b/src/cwiresxpacketqueue.h
@@ -0,0 +1,54 @@
+//
+//  cwiresxpacketqueue.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 09/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cwiresxpacketqueue_h
+#define cwiresxpacketqueue_h
+
+#include "cwiresxpacket.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CWiresxPacketQueue : public std::queue<CWiresxPacket>
+{
+public:
+    // constructor
+    CWiresxPacketQueue() {};
+    
+    // destructor
+    ~CWiresxPacketQueue() {};
+    
+    // lock
+    void Lock()                 { m_Mutex.lock(); }
+    void Unlock()               { m_Mutex.unlock(); }
+    
+protected:
+    // status
+    std::mutex  m_Mutex;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cwiresxpacketqueue_h */
diff --git a/src/cysfclient.cpp b/src/cysfclient.cpp
new file mode 100644
index 0000000..fd28c9f
--- /dev/null
+++ b/src/cysfclient.cpp
@@ -0,0 +1,52 @@
+//
+//  cysfclient.cpp
+//  xlxd
+////  Created by Jean-Luc on 20/05/2018.
+//  Created by Jean-Luc Deltombe (LX3JL) on 20/05/2018.
+//  Copyright © 2015 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include "main.h"
+#include "cysfclient.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructors
+
+CYsfClient::CYsfClient()
+{
+}
+
+CYsfClient::CYsfClient(const CCallsign &callsign, const CIp &ip, char reflectorModule)
+    : CClient(callsign, ip, reflectorModule)
+{
+}
+
+CYsfClient::CYsfClient(const CYsfClient &client)
+    : CClient(client)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// status
+
+bool CYsfClient::IsAlive(void) const
+{
+    return (m_LastKeepaliveTime.DurationSinceNow() < YSF_KEEPALIVE_TIMEOUT);
+}
diff --git a/src/cysfclient.h b/src/cysfclient.h
new file mode 100644
index 0000000..7fb11d2
--- /dev/null
+++ b/src/cysfclient.h
@@ -0,0 +1,59 @@
+//
+//  cysfclient.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 20/05/2018.
+//  Copyright © 2015 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cysfclient_h
+#define cysfclient_h
+
+#include "cclient.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// define
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CYsfClient : public CClient
+{
+public:
+    // constructors
+    CYsfClient();
+    CYsfClient(const CCallsign &, const CIp &, char = ' ');
+    CYsfClient(const CYsfClient &);
+    
+    // destructor
+    virtual ~CYsfClient() {};
+    
+    // identity
+    int GetProtocol(void) const                 { return PROTOCOL_YSF; }
+    const char *GetProtocolName(void) const     { return "YSF"; }
+    int GetCodec(void) const                    { return CODEC_AMBE2PLUS; }
+    bool IsNode(void) const                     { return true; }
+    
+    // status
+    bool IsAlive(void) const;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfclient_h */
diff --git a/src/cysfconvolution.cpp b/src/cysfconvolution.cpp
new file mode 100644
index 0000000..f397ec0
--- /dev/null
+++ b/src/cysfconvolution.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 "cysfconvolution.h"
+
+#include <cstdio>
+#include <cassert>
+#include <cstring>
+
+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/src/cysfconvolution.h b/src/cysfconvolution.h
new file mode 100644
index 0000000..b681472
--- /dev/null
+++ b/src/cysfconvolution.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 "cysfconvolution.h"
+
+#include <cstdint>
+
+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/src/cysffich.cpp b/src/cysffich.cpp
new file mode 100644
index 0000000..36a093b
--- /dev/null
+++ b/src/cysffich.cpp
@@ -0,0 +1,308 @@
+/*
+ *   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 "cysfconvolution.h"
+#include "ysfdefines.h"
+#include "cgolay24128.h"
+#include "cysffich.h"
+#include "ccrc.h"
+//#include "Log.h"
+
+#include <cstdio>
+#include <cassert>
+#include <cstring>
+
+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];
+    ::memset(m_fich, 0U, 6U);
+}
+
+CYSFFICH::~CYSFFICH()
+{
+    delete[] m_fich;
+}
+
+bool CYSFFICH::decode(const unsigned char* bytes)
+{
+    assert(bytes != NULL);
+    
+    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);
+    
+    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/src/cysffich.h b/src/cysffich.h
new file mode 100644
index 0000000..7adcad8
--- /dev/null
+++ b/src/cysffich.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/src/cysfnode.cpp b/src/cysfnode.cpp
new file mode 100644
index 0000000..e97f98f
--- /dev/null
+++ b/src/cysfnode.cpp
@@ -0,0 +1,60 @@
+//
+//  cysfnode.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include <string.h>
+#include "main.h"
+#include "cysfnode.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+///// constructor
+
+CYsfNode::CYsfNode()
+{
+    m_uiTxFreq = 0;
+    m_uiRxFreq = 0;
+}
+
+CYsfNode::CYsfNode(const CCallsign &callsign, uint32 txfreq, uint32 rxfreq)
+{
+    m_Callsign = callsign;
+    m_uiTxFreq = txfreq;
+    m_uiRxFreq = rxfreq;
+}
+
+CYsfNode::CYsfNode(const CYsfNode &node)
+{
+    m_Callsign = node.m_Callsign;
+    m_uiTxFreq = node.m_uiTxFreq;
+    m_uiRxFreq = node.m_uiRxFreq;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// get
+
+bool CYsfNode::IsValid(void) const
+{
+    return m_Callsign.IsValid();
+}
diff --git a/src/cysfnode.h b/src/cysfnode.h
new file mode 100644
index 0000000..65fb6e6
--- /dev/null
+++ b/src/cysfnode.h
@@ -0,0 +1,62 @@
+//
+//  cysfnode.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cysfnode_h
+#define cysfnode_h
+
+#include "main.h"
+#include "ccallsign.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// define
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CYsfNode
+{
+public:
+    // constructor
+    CYsfNode();
+    CYsfNode(const CCallsign &, uint32, uint32);
+    CYsfNode(const CYsfNode &);
+    
+    // destructor
+    virtual ~CYsfNode() {}
+    
+    // get
+    uint32  GetTxFrequency(void) const          { return m_uiTxFreq; }
+    uint32  GetRxFrequency(void) const          { return m_uiRxFreq; }
+    bool       IsValid(void) const;
+    
+protected:
+    // data
+    CCallsign   m_Callsign;
+    uint32      m_uiTxFreq;
+    uint32      m_uiRxFreq;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfnode_h */
diff --git a/src/cysfnodedir.cpp b/src/cysfnodedir.cpp
new file mode 100644
index 0000000..a8722af
--- /dev/null
+++ b/src/cysfnodedir.cpp
@@ -0,0 +1,135 @@
+//
+//  cysfnodedir.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include <string.h>
+#include "main.h"
+#include "creflector.h"
+#include "cysfnodedir.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructor & destructor
+
+CYsfNodeDir::CYsfNodeDir()
+{
+    m_bStopThread = false;
+    m_pThread = NULL;
+}
+
+CYsfNodeDir::~CYsfNodeDir()
+{
+    // kill threads
+    m_bStopThread = true;
+    if ( m_pThread != NULL )
+    {
+        m_pThread->join();
+        delete m_pThread;
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// init & close
+
+bool CYsfNodeDir::Init(void)
+{
+    // load content
+    Reload();
+    
+    // reset stop flag
+    m_bStopThread = false;
+    
+    // start  thread;
+    m_pThread = new std::thread(CYsfNodeDir::Thread, this);
+
+    return true;
+}
+
+void CYsfNodeDir::Close(void)
+{
+    m_bStopThread = true;
+    if ( m_pThread != NULL )
+    {
+        m_pThread->join();
+        delete m_pThread;
+        m_pThread = NULL;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// thread
+
+void CYsfNodeDir::Thread(CYsfNodeDir *This)
+{
+    while ( !This->m_bStopThread )
+    {
+        // Wait 30 seconds
+        CTimePoint::TaskSleepFor(YSFNODEDB_REFRESH_RATE * 60000);
+
+        // have lists files changed ?
+        if ( This->NeedReload() )
+        {
+               This->Reload();
+        }
+     }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Reload
+
+bool CYsfNodeDir::Reload(void)
+{
+    CBuffer buffer;
+    bool ok = false;
+    
+    if ( LoadContent(&buffer) )
+    {
+        Lock();
+        {
+            ok = RefreshContent(buffer);
+        }
+        Unlock();
+    }
+    return ok;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// find
+
+bool CYsfNodeDir::FindFrequencies(const CCallsign &callsign, uint32 *txfreq, uint32 *rxfreq)
+{
+    auto found = find(callsign);
+    if ( found != end() )
+    {
+        *txfreq = found->second.GetTxFrequency();
+        *rxfreq = found->second.GetRxFrequency();
+        return true;
+    }
+    else
+    {
+        *txfreq = YSF_DEFAULT_NODE_TX_FREQ;
+        *rxfreq = YSF_DEFAULT_NODE_RX_FREQ;
+        return false;
+    }
+}
diff --git a/src/cysfnodedir.h b/src/cysfnodedir.h
new file mode 100644
index 0000000..b4e3804
--- /dev/null
+++ b/src/cysfnodedir.h
@@ -0,0 +1,95 @@
+//
+//  cysfnodedir.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cysfnodedir_h
+#define cysfnodedir_h
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include "cbuffer.h"
+#include "ccallsign.h"
+#include "cysfnode.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// define
+
+
+// compare function for std::map::find
+
+struct CYsfNodeDirCallsignCompare
+{
+    bool operator() (const CCallsign &cs1, const CCallsign &cs2) const
+    { return cs1.HasLowerCallsign(cs2);}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CYsfNodeDir : public std::map <CCallsign, CYsfNode, CYsfNodeDirCallsignCompare>
+{
+public:
+    // constructor
+    CYsfNodeDir();
+    // destructor
+    virtual ~CYsfNodeDir();
+
+     // init & close
+    virtual bool Init(void);
+    virtual void Close(void);
+    
+    // locks
+    void Lock(void)                                 { m_Mutex.lock(); }
+    void Unlock(void)                               { m_Mutex.unlock(); }
+    
+    // refresh
+    virtual bool LoadContent(CBuffer *)             { return false; }
+    virtual bool RefreshContent(const CBuffer &)    { return false; }
+
+    // find
+    bool FindFrequencies(const CCallsign &, uint32 *, uint32 *);
+
+protected:
+    // thread
+    static void Thread(CYsfNodeDir *);
+
+    // reload helpers
+    bool Reload(void);
+    virtual bool NeedReload(void)                    { return false; }
+    //bool IsValidDmrid(const char *);
+    
+
+protected:
+    // Lock()
+     std::mutex          m_Mutex;
+            
+     // thread
+     bool                m_bStopThread;
+     std::thread         *m_pThread;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfnodedir_h */
diff --git a/src/cysfnodedirfile.cpp b/src/cysfnodedirfile.cpp
new file mode 100644
index 0000000..46da902
--- /dev/null
+++ b/src/cysfnodedirfile.cpp
@@ -0,0 +1,167 @@
+//
+//  cysfnodedirfile.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include "main.h"
+#include "cysfnodedirfile.h"
+
+
+#if (YSFNODEDB_USE_RLX_SERVER == 0)
+CYsfNodeDirFile   g_YsfNodeDir;
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructor & destructor
+
+CYsfNodeDirFile::CYsfNodeDirFile()
+{
+    ::memset(&m_LastModTime, 0, sizeof(time_t));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// init & close
+
+bool CYsfNodeDirFile::Init(void)
+{
+    return CYsfNodeDir::Init();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// refresh
+
+bool CYsfNodeDirFile::NeedReload(void)
+{
+    bool needReload = false;
+    
+    time_t time;
+    if ( GetLastModTime(&time) )
+    {
+        needReload = time != m_LastModTime;
+    }
+    return needReload;
+}
+
+bool CYsfNodeDirFile::LoadContent(CBuffer *buffer)
+{
+    bool ok = false;
+    std::ifstream file;
+    std::streampos size;
+    
+    // open file
+    file.open(YSFNODEDB_PATH, std::ios::in | std::ios::binary | std::ios::ate);
+    if ( file.is_open() )
+    {
+        // read file
+        size = file.tellg();
+        if ( size > 0 )
+        {
+            // read file into buffer
+            buffer->resize((int)size+1);
+            file.seekg (0, std::ios::beg);
+            file.read((char *)buffer->data(), (int)size);
+            
+            // close file
+            file.close();
+            
+            // update time
+            GetLastModTime(&m_LastModTime);
+            
+            // done
+            ok = true;
+        }
+    }
+    
+    // done
+    return ok;
+}
+
+bool CYsfNodeDirFile::RefreshContent(const CBuffer &buffer)
+{
+    bool ok = false;
+    
+    // clear directory
+    clear();
+    
+    // scan buffer    
+    if ( buffer.size() > 0 )
+    {
+        // crack it
+        char *ptr1 = (char *)buffer.data();
+        char *ptr2;
+        
+        // get next line
+        while ( (ptr2 = ::strchr(ptr1, '\n')) != NULL )
+        {
+            *ptr2 = 0;
+            // get items
+            char *callsign;
+            char *txfreq;
+            char *rxfreq;
+            if ( ((callsign = ::strtok(ptr1, ";")) != NULL) )
+            {
+                if ( ((txfreq = ::strtok(NULL, ";")) != NULL) )
+                {
+                    if ( ((rxfreq = ::strtok(NULL, ";")) != NULL) )
+                    {
+                        // new entry
+                        CCallsign cs(callsign);
+                        CYsfNode node(cs, atoi(txfreq), atoi(rxfreq));
+                        if ( cs.IsValid() && node.IsValid() )
+                        {
+                            insert(std::pair<CCallsign, CYsfNode>(cs, node));
+                        }
+                    }
+                }
+            }
+            // next line
+            ptr1 = ptr2+1;
+        }
+        
+        // done
+        ok = true;
+    }
+
+    
+    // report
+    std::cout << "Read " << size() << " YSF nodes from file " << YSFNODEDB_PATH << std::endl;
+    
+    // done
+    return ok;
+}
+
+
+bool CYsfNodeDirFile::GetLastModTime(time_t *time)
+{
+    bool ok = false;
+    
+    struct stat fileStat;
+    if( ::stat(YSFNODEDB_PATH, &fileStat) != -1 )
+    {
+        *time = fileStat.st_mtime;
+        ok = true;
+    }
+    return ok;
+}
diff --git a/src/cysfnodedirfile.h b/src/cysfnodedirfile.h
new file mode 100644
index 0000000..8106a7e
--- /dev/null
+++ b/src/cysfnodedirfile.h
@@ -0,0 +1,59 @@
+//
+//  cysfnodedirfile.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cysfnodedirfile_h
+#define cysfnodedirfile_h
+
+#include "cysfnodedir.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+class CYsfNodeDirFile : public CYsfNodeDir
+{
+public:
+    // constructor
+    CYsfNodeDirFile();
+    
+    // destructor
+    ~CYsfNodeDirFile() {}
+    
+    // init & close
+    bool Init(void);
+    
+    // refresh
+    bool LoadContent(CBuffer *);
+    bool RefreshContent(const CBuffer &);
+    
+protected:
+    // reload helpers
+    bool NeedReload(void);
+    bool GetLastModTime(time_t *);
+    
+protected:
+    // data
+    time_t      m_LastModTime;
+ };
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfnodedirfile_h */
diff --git a/src/cysfnodedirhttp.cpp b/src/cysfnodedirhttp.cpp
new file mode 100644
index 0000000..739e66a
--- /dev/null
+++ b/src/cysfnodedirhttp.cpp
@@ -0,0 +1,184 @@
+//
+//  cysfnodedirhttp.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include <string.h>
+#include "main.h"
+#include "creflector.h"
+#include "cysfnodedirhttp.h"
+
+#if (YSFNODEDB_USE_RLX_SERVER == 1)
+CYsfNodeDirHttp g_YsfNodeDir;
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// refresh
+
+bool CYsfNodeDirHttp::LoadContent(CBuffer *buffer)
+{
+    // get file from xlxapi server
+    return HttpGet("xlxapi.rlx.lu", "api/exportysfrepeaters.php", 80, buffer);
+}
+
+bool CYsfNodeDirHttp::RefreshContent(const CBuffer &buffer)
+{
+    bool ok = false;
+
+    // clear directory
+    clear();
+    
+    // scan buffer
+    if ( buffer.size() > 0 )
+    {
+        // crack it
+        char *ptr1 = (char *)buffer.data();
+        char *ptr2;
+        
+        // get next line
+        while ( (ptr2 = ::strchr(ptr1, '\n')) != NULL )
+        {
+            *ptr2 = 0;
+            // get items
+            char *callsign;
+            char *txfreq;
+            char *rxfreq;
+            if ( ((callsign = ::strtok(ptr1, ";")) != NULL) )
+            {
+                if ( ((txfreq = ::strtok(NULL, ";")) != NULL) )
+                {
+                    if ( ((rxfreq = ::strtok(NULL, ";")) != NULL) )
+                    {
+                        // new entry
+                        CCallsign cs(callsign);
+                        CYsfNode node(cs, atoi(txfreq), atoi(rxfreq));
+                        if ( cs.IsValid() && node.IsValid() )
+                        {
+                            insert(std::pair<CCallsign, CYsfNode>(cs, node));
+                        }
+                    }
+                }
+            }
+            // next line
+            ptr1 = ptr2+1;
+        }
+        
+        // done
+        ok = true;
+    }
+    
+    // report
+    std::cout << "Read " << size() << " YSF nodes from xlxapi.rlx.lu database " << std::endl;
+    
+    // done
+    return ok;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// httpd helpers
+
+#define YSFNODE_HTTPGET_SIZEMAX       (256)
+
+bool CYsfNodeDirHttp::HttpGet(const char *hostname, const char *filename, int port, CBuffer *buffer)
+{
+    bool ok = false;
+    int sock_id;
+    
+    // open socket
+    if ( (sock_id = ::socket(AF_INET, SOCK_STREAM, 0)) >= 0 )
+    {
+        // get hostname address
+        struct sockaddr_in servaddr;
+        struct hostent *hp;
+        ::memset(&servaddr,0,sizeof(servaddr));
+        if( (hp = gethostbyname(hostname)) != NULL )
+        {
+            // dns resolved
+            ::memcpy((char *)&servaddr.sin_addr.s_addr, (char *)hp->h_addr, hp->h_length);
+            servaddr.sin_port = htons(port);
+            servaddr.sin_family = AF_INET;
+            
+            // connect
+            if ( ::connect(sock_id, (struct sockaddr *)&servaddr, sizeof(servaddr)) == 0)
+            {
+                // send the GET request
+                char request[YSFNODE_HTTPGET_SIZEMAX];
+                ::sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: xlxd\r\n\r\n",
+                          filename, (const char *)g_Reflector.GetCallsign());
+                ::write(sock_id, request, strlen(request));
+                
+                // config receive timeouts
+                fd_set read_set;
+                struct timeval timeout;
+                timeout.tv_sec = 5;
+                timeout.tv_usec = 0;
+                FD_ZERO(&read_set);
+                FD_SET(sock_id, &read_set);
+                
+                // get the reply back
+                buffer->clear();
+                bool done = false;
+                do
+                {
+                    char buf[1440];
+                    ssize_t len = 0;
+                    select(sock_id+1, &read_set, NULL, NULL, &timeout);
+                    //if ( (ret > 0) || ((ret < 0) && (errno == EINPROGRESS)) )
+                    //if ( ret >= 0 )
+                    //{
+                    usleep(5000);
+                    len = read(sock_id, buf, 1440);
+                    if ( len > 0 )
+                    {
+                        buffer->Append((uint8 *)buf, (int)len);
+                        ok = true;
+                    }
+                    //}
+                    done = (len <= 0);
+                    
+                } while (!done);
+                buffer->Append((uint8)0);
+                
+                // and disconnect
+                close(sock_id);
+            }
+            else
+            {
+                std::cout << "Cannot establish connection with host " << hostname << std::endl;
+            }
+        }
+        else
+        {
+            std::cout << "Host " << hostname << " not found" << std::endl;
+        }
+        
+    }
+    else
+    {
+        std::cout << "Failed to open wget socket" << std::endl;
+    }
+    
+    // done
+    return ok;
+}
diff --git a/src/cysfnodedirhttp.h b/src/cysfnodedirhttp.h
new file mode 100644
index 0000000..3997fcb
--- /dev/null
+++ b/src/cysfnodedirhttp.h
@@ -0,0 +1,53 @@
+//
+//  cysfnodedirhttp.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 08/10/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cysfnodedirhttp_h
+#define cysfnodedirhttp_h
+
+
+#include "cysfnodedir.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+class CYsfNodeDirHttp : public CYsfNodeDir
+{
+public:
+    // constructor
+    CYsfNodeDirHttp() {}
+    
+    // destructor
+    ~CYsfNodeDirHttp() {}
+    
+    // refresh
+    bool LoadContent(CBuffer *);
+    bool RefreshContent(const CBuffer &);
+    
+protected:
+    // reload helpers
+    bool NeedReload(void)  { return true; }
+    bool HttpGet(const char *, const char *, int, CBuffer *);
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfnodedirhttp_h */
diff --git a/src/cysfpayload.cpp b/src/cysfpayload.cpp
new file mode 100644
index 0000000..dd240ac
--- /dev/null
+++ b/src/cysfpayload.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 "cysfconvolution.h"
+#include "cysfpayload.h"
+#include "ysfdefines.h"
+#include "cutils.h"
+#include "ccrc.h"
+
+
+#include <cstdio>
+#include <cassert>
+#include <cstring>
+#include <cstdint>
+
+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, YSF_CALLSIGN_LENGTH);
+    else
+        tmp = "";
+    
+    return tmp;
+}
+
+void CYSFPayload::reset()
+{
+    delete[] m_source;
+    delete[] m_dest;
+    
+    m_source = NULL;
+    m_dest = NULL;
+}
diff --git a/src/cysfpayload.h b/src/cysfpayload.h
new file mode 100644
index 0000000..b741037
--- /dev/null
+++ b/src/cysfpayload.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 <string>
+
+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/src/cysfprotocol.cpp b/src/cysfprotocol.cpp
new file mode 100644
index 0000000..6dc3a1e
--- /dev/null
+++ b/src/cysfprotocol.cpp
@@ -0,0 +1,1061 @@
+//
+//  cysfprotocol.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 20/05/2018.
+//  Copyright © 2015 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include "main.h"
+#include <string.h>
+#include "ccrc.h"
+#include "cysfpayload.h"
+#include "cysfclient.h"
+#include "cysfnodedirfile.h"
+#include "cysfnodedirhttp.h"
+#include "cysfutils.h"
+#include "cysfprotocol.h"
+#include "creflector.h"
+#include "cgatekeeper.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constructor
+CYsfProtocol::CYsfProtocol()
+{
+    m_seqNo = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// operation
+
+bool CYsfProtocol::Init(void)
+{
+    bool ok;
+    
+    // base class
+    ok = CProtocol::Init();
+    
+    // update the reflector callsign
+    m_ReflectorCallsign.PatchCallsign(0, (const uint8 *)"YSF", 3);
+    
+    // create our socket
+    ok &= m_Socket.Open(YSF_PORT);
+    if ( !ok )
+    {
+        std::cout << "Error opening socket on port UDP" << YSF_PORT << " on ip " << g_Reflector.GetListenIp() << std::endl;
+    }
+    
+    // init the wiresx cmd handler
+    ok &= m_WiresxCmdHandler.Init();
+    
+    // update time
+    m_LastKeepaliveTime.Now();
+    
+    // done
+    return ok;
+}
+
+void CYsfProtocol::Close(void)
+{
+    // base class
+    CProtocol::Close();
+    
+    // and close wiresx handler
+    m_WiresxCmdHandler.Close();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// task
+
+void CYsfProtocol::Task(void)
+{
+    CBuffer             Buffer;
+    CIp                 Ip;
+    CCallsign           Callsign;
+    CYSFFICH            Fich;
+    CDvHeaderPacket     *Header;
+    CDvFramePacket      *Frames[5];
+    CWiresxCmd          WiresxCmd;
+    
+    int                 iWiresxCmd;
+    int                 iWiresxArg;
+
+    // handle outgoing packets
+    {
+        // any packet to go ?
+        CWiresxPacketQueue *queue = m_WiresxCmdHandler.GetPacketQueue();
+        while ( !queue->empty() )
+        {
+            CWiresxPacket packet = queue->front();
+            queue->pop();
+            m_Socket.Send(packet.GetBuffer(), packet.GetIp());
+        }
+        m_WiresxCmdHandler.ReleasePacketQueue();
+    }
+    
+    // handle incoming packets
+    if ( m_Socket.Receive(&Buffer, &Ip, 20) != -1 )
+    {
+        // crack the packet
+        if ( IsValidDvPacket(Buffer, &Fich) )
+        {
+           //std::cout << "FN = " << (int)Fich.getFN() << "  FT = " << (int)Fich.getFT() << std::endl;
+            if ( IsValidDvFramePacket(Ip, Fich, Buffer, Frames) )
+            {
+                //std::cout << "YSF DV frame"  << std::endl;
+                
+                // handle it
+                OnDvFramePacketIn(Frames[0], &Ip);
+                OnDvFramePacketIn(Frames[1], &Ip);
+                OnDvFramePacketIn(Frames[2], &Ip);
+                OnDvFramePacketIn(Frames[3], &Ip);
+                OnDvFramePacketIn(Frames[4], &Ip);
+            }
+            else if ( IsValidDvHeaderPacket(Ip, Fich, Buffer, &Header, Frames) )
+            {
+                //std::cout << "YSF DV header:"  << std::endl << *Header << std::endl;
+                //std::cout << "YSF DV header:"  << std::endl;
+                
+                // node linked and callsign muted?
+                if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_YSF, Header->GetRpt2Module())  )
+                {
+                    // handle it
+                    OnDvHeaderPacketIn(Header, Ip);
+                    //OnDvFramePacketIn(Frames[0], &Ip);
+                    //OnDvFramePacketIn(Frames[1], &Ip);
+                }
+                else
+                {
+                    delete Header;
+                }
+            }
+            else if ( IsValidDvLastFramePacket(Ip, Fich, Buffer, Frames) )
+            {
+                //std::cout << "YSF last DV frame"  << std::endl;
+
+                // handle it
+                OnDvFramePacketIn(Frames[0], &Ip);
+                OnDvLastFramePacketIn((CDvLastFramePacket *)Frames[1], &Ip);
+            }
+        }
+        else if ( IsValidConnectPacket(Buffer, &Callsign) )
+        {
+            //std::cout << "YSF keepalive/connect packet from " << Callsign << " at " << Ip << std::endl;
+            
+            // callsign authorized?
+            if ( g_GateKeeper.MayLink(Callsign, Ip, PROTOCOL_YSF) )
+            {
+                // acknowledge the request
+                EncodeConnectAckPacket(&Buffer);
+                m_Socket.Send(Buffer, Ip);
+                
+                // add client if needed
+                CClients *clients = g_Reflector.GetClients();
+                CClient *client = clients->FindClient(Callsign, Ip, PROTOCOL_YSF);
+                // client already connected ?
+                if ( client == NULL )
+                {
+                    std::cout << "YSF connect packet from " << Callsign << " at " << Ip << std::endl;
+                    
+                    // create the client
+                    CYsfClient *newclient = new CYsfClient(Callsign, Ip);
+                    
+                    // and append
+                    clients->AddClient(newclient);
+                }
+                else
+                {
+                    client->Alive();
+                }
+                // and done
+                g_Reflector.ReleaseClients();
+            }
+        }
+        else if ( IsValidwirexPacket(Buffer, &Fich, &Callsign, &iWiresxCmd, &iWiresxArg) )
+        {
+            //std::cout << "YSF Wires-x frame"  << std::endl;
+            // prepare the cmd object
+            WiresxCmd = CWiresxCmd(Ip, Callsign, iWiresxCmd, iWiresxArg);
+            // and post it to hadler's queue
+            m_WiresxCmdHandler.GetCmdQueue()->push(WiresxCmd);
+            m_WiresxCmdHandler.ReleaseCmdQueue();
+         }
+        else
+        {
+            // invalid packet
+            //std::cout << "YSF packet (" << Buffer.size() << ") from " << Callsign << " at " << Ip << std::endl;
+            //Buffer.DebugDump(g_Reflector.m_DebugFile);
+        }
+    }
+    
+    // handle end of streaming timeout
+    CheckStreamsTimeout();
+    
+    // handle queue from reflector
+    HandleQueue();
+    
+    // keep client alive
+    if ( m_LastKeepaliveTime.DurationSinceNow() > YSF_KEEPALIVE_PERIOD )
+    {
+        //
+        HandleKeepalives();
+        
+        // update time
+        m_LastKeepaliveTime.Now();
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// streams helpers
+
+bool CYsfProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip)
+{
+    bool newstream = false;
+    
+    // find the stream
+    CPacketStream *stream = GetStream(Header->GetStreamId());
+    if ( stream == NULL )
+    {
+        // no stream open yet, open a new one
+        CCallsign via(Header->GetRpt1Callsign());
+        
+        // find this client
+        CClient *client = g_Reflector.GetClients()->FindClient(Ip, PROTOCOL_YSF);
+        if ( client != NULL )
+        {
+            // get client callsign
+            via = client->GetCallsign();
+            // get module it's linked to
+            Header->SetRpt2Module(client->GetReflectorModule());
+
+            // and try to open the stream
+            if ( (stream = g_Reflector.OpenStream(Header, client)) != NULL )
+            {
+                // keep the handle
+                m_Streams.push_back(stream);
+                newstream = true;
+            }
+        }
+        // release
+        g_Reflector.ReleaseClients();
+        
+        // update last heard
+        if ( g_Reflector.IsValidModule(Header->GetRpt2Module()) )
+        {
+            g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign());
+            g_Reflector.ReleaseUsers();
+        }
+        
+        // delete header if needed
+        if ( !newstream )
+        {
+            delete Header;
+        }
+    }
+    else
+    {
+        // stream already open
+        // skip packet, but tickle the stream
+        stream->Tickle();
+        // and delete packet
+        delete Header;
+    }
+    
+    // done
+    return newstream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// queue helper
+
+void CYsfProtocol::HandleQueue(void)
+{
+    
+    m_Queue.Lock();
+    while ( !m_Queue.empty() )
+    {
+        // get the packet
+        CPacket *packet = m_Queue.front();
+        m_Queue.pop();
+        
+        // get our sender's id
+        int iModId = g_Reflector.GetModuleIndex(packet->GetModuleId());
+        
+        // encode
+        CBuffer buffer;
+        
+        // check if it's header
+        if ( packet->IsDvHeader() )
+        {
+            // update local stream cache
+            // this relies on queue feeder setting valid module id
+            m_StreamsCache[iModId].m_dvHeader = CDvHeaderPacket((const CDvHeaderPacket &)*packet);
+            
+            // encode it
+            EncodeDvHeaderPacket((const CDvHeaderPacket &)*packet, &buffer);
+        }
+        // check if it's a last frame
+        else if ( packet->IsLastPacket() )
+        {
+            // encode it
+            EncodeDvLastPacket(m_StreamsCache[iModId].m_dvHeader, &buffer);
+        }
+        // otherwise, just a regular DV frame
+        else
+        {
+            // update local stream cache or send triplet when needed
+            uint8 sid = packet->GetYsfPacketSubId();
+            if ( (sid >= 0) && (sid <= 4) )
+            {
+                //std::cout << (int)sid;
+                m_StreamsCache[iModId].m_dvFrames[sid] = CDvFramePacket((const CDvFramePacket &)*packet);
+                if ( sid == 4 )
+                {
+                    
+                    EncodeDvPacket(m_StreamsCache[iModId].m_dvHeader, m_StreamsCache[iModId].m_dvFrames, &buffer);
+                }
+            }
+        }
+        
+        // send it
+        if ( buffer.size() > 0 )
+        {
+            // and push it to all our clients linked to the module and who are not streaming in
+            CClients *clients = g_Reflector.GetClients();
+            int index = -1;
+            CClient *client = NULL;
+            while ( (client = clients->FindNextClient(PROTOCOL_YSF, &index)) != NULL )
+            {
+                // is this client busy ?
+                if ( !client->IsAMaster() && (client->GetReflectorModule() == packet->GetModuleId()) )
+                {
+                    // no, send the packet
+                    m_Socket.Send(buffer, client->GetIp());
+                    
+                }
+            }
+            g_Reflector.ReleaseClients();
+        }
+        
+        // done
+        delete packet;
+    }
+    m_Queue.Unlock();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// keepalive helpers
+
+void CYsfProtocol::HandleKeepalives(void)
+{
+    // YSF protocol keepalive request is client tasks
+    // here, just check that all clients are still alive
+    // and disconnect them if not
+    
+    // iterate on clients
+    CClients *clients = g_Reflector.GetClients();
+    int index = -1;
+    CClient *client = NULL;
+    while ( (client = clients->FindNextClient(PROTOCOL_YSF, &index)) != NULL )
+    {
+        // is this client busy ?
+        if ( client->IsAMaster() )
+        {
+            // yes, just tickle it
+            client->Alive();
+        }
+        // check it's still with us
+        else if ( !client->IsAlive() )
+        {
+            // no, remove it
+            std::cout << "YSF client " << client->GetCallsign() << " keepalive timeout" << std::endl;
+            clients->RemoveClient(client);
+        }
+        
+    }
+    g_Reflector.ReleaseClients();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// DV packet decoding helpers
+
+bool CYsfProtocol::IsValidConnectPacket(const CBuffer &Buffer, CCallsign *callsign)
+{
+    uint8 tag[] = { 'Y','S','F','P' };
+
+    bool valid = false;
+    if ( (Buffer.size() == 14) && (Buffer.Compare(tag, sizeof(tag)) == 0) )
+    {
+        callsign->SetCallsign(Buffer.data()+4, 8);
+        callsign->SetModule(YSF_MODULE_ID);
+        valid = (callsign->IsValid());
+    }
+    return valid;
+}
+
+bool CYsfProtocol::IsValidDvPacket(const CBuffer &Buffer, CYSFFICH *Fich)
+{
+    uint8 tag[] = { 'Y','S','F','D' };
+    
+    bool valid = false;
+
+    if ( (Buffer.size() == 155) && (Buffer.Compare(tag, sizeof(tag)) == 0) )
+    {
+        // decode YSH fich
+        if ( Fich->decode(&(Buffer.data()[40])) )
+        {
+            valid = (Fich->getDT() == YSF_DT_VD_MODE2);
+        }
+    }
+    return valid;
+}
+
+
+bool CYsfProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, CDvHeaderPacket **header, CDvFramePacket **frames)
+{
+    bool valid = false;
+    *header = NULL;
+    frames[0] = NULL;
+    frames[1] = NULL;
+
+    // DV header ?
+    if ( Fich.getFI() == YSF_FI_HEADER )
+    {
+        // get stream id
+        uint32 uiStreamId = IpToStreamId(Ip);
+        
+        // get header data
+        CYSFPayload ysfPayload;
+        if ( ysfPayload.processHeaderData((unsigned char *)&(Buffer.data()[35])) )
+        {
+            // build DVHeader
+             char sz[YSF_CALLSIGN_LENGTH+1];
+            ::memcpy(sz, &(Buffer.data()[14]), YSF_CALLSIGN_LENGTH);
+            sz[YSF_CALLSIGN_LENGTH] = 0;
+            CCallsign csMY = CCallsign((const char *)sz);
+            ::memcpy(sz, &(Buffer.data()[4]), YSF_CALLSIGN_LENGTH);
+            sz[YSF_CALLSIGN_LENGTH] = 0;
+            CCallsign rpt1 = CCallsign((const char *)sz);
+            rpt1.SetModule(YSF_MODULE_ID);
+            CCallsign rpt2 = m_ReflectorCallsign;
+            // as YSF protocol does not provide a module-tranlatable
+            // destid, set module to none and rely on OnDvHeaderPacketIn()
+            // to later fill it with proper value
+            rpt2.SetModule(' ');
+            
+            // and packet
+            *header = new CDvHeaderPacket(csMY, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, Fich.getFN());
+        }
+        // and 2 DV Frames
+        {
+            uint8  uiAmbe[AMBE_SIZE];
+            ::memset(uiAmbe, 0x00, sizeof(uiAmbe));
+            frames[0] = new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 0, 0);
+            frames[1] = new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 1, 0);
+        }
+        
+        // check validity of packets
+        if ( ((*header) == NULL) || !(*header)->IsValid() ||
+             (frames[0] == NULL) || !(frames[0]->IsValid()) ||
+             (frames[1] == NULL) || !(frames[1]->IsValid()) )
+
+        {
+            delete *header;
+            *header = NULL;
+            delete frames[0];
+            delete frames[1];
+            frames[0] = NULL;
+            frames[1] = NULL;
+        }
+        else
+        {
+            valid = true;
+         }
+
+    }
+    
+    // done
+    return valid;
+}
+
+bool CYsfProtocol::IsValidDvFramePacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, CDvFramePacket **frames)
+{
+    bool valid = false;
+    frames[0] = NULL;
+    frames[1] = NULL;
+    frames[2] = NULL;
+    frames[3] = NULL;
+    frames[4] = NULL;
+    
+    // is it DV frame ?
+    if ( Fich.getFI() == YSF_FI_COMMUNICATIONS )
+    {
+        // get stream id
+        uint32 uiStreamId = IpToStreamId(Ip);
+        
+        // get DV frames
+        uint8   ambe0[AMBEPLUS_SIZE];
+        uint8   ambe1[AMBEPLUS_SIZE];
+        uint8   ambe2[AMBEPLUS_SIZE];
+        uint8   ambe3[AMBEPLUS_SIZE];
+        uint8   ambe4[AMBEPLUS_SIZE];
+        uint8 *ambes[5] = { ambe0, ambe1, ambe2, ambe3, ambe4 };
+        CYsfUtils::DecodeVD2Vchs((unsigned char *)&(Buffer.data()[35]), ambes);
+
+        // get DV frames
+        uint8 fid = Buffer.data()[34];
+        frames[0] = new CDvFramePacket(ambe0, uiStreamId, Fich.getFN(), 0, fid);
+        frames[1] = new CDvFramePacket(ambe1, uiStreamId, Fich.getFN(), 1, fid);
+        frames[2] = new CDvFramePacket(ambe2, uiStreamId, Fich.getFN(), 2, fid);
+        frames[3] = new CDvFramePacket(ambe3, uiStreamId, Fich.getFN(), 3, fid);
+        frames[4] = new CDvFramePacket(ambe4, uiStreamId, Fich.getFN(), 4, fid);
+        
+        // check validity of packets
+        if ( (frames[0] == NULL) || !(frames[0]->IsValid()) ||
+            (frames[1] == NULL) || !(frames[1]->IsValid()) ||
+            (frames[2] == NULL) || !(frames[2]->IsValid()) ||
+            (frames[3] == NULL) || !(frames[3]->IsValid()) ||
+            (frames[4] == NULL) || !(frames[4]->IsValid()) )
+        {
+            delete frames[0];
+            delete frames[1];
+            delete frames[2];
+            delete frames[3];
+            delete frames[4];
+            frames[0] = NULL;
+            frames[1] = NULL;
+            frames[2] = NULL;
+            frames[3] = NULL;
+            frames[4] = NULL;
+        }
+        else
+        {
+            valid = true;
+        }
+    }
+
+    // done
+    return valid;
+}
+
+bool CYsfProtocol::IsValidDvLastFramePacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, CDvFramePacket **frames)
+{
+    bool valid = false;
+    frames[0] = NULL;
+    frames[1] = NULL;
+    
+    // DV header ?
+    if ( Fich.getFI() == YSF_FI_TERMINATOR )
+    {
+        // get stream id
+        uint32 uiStreamId = IpToStreamId(Ip);
+        
+        // get DV frames
+        {
+            uint8  uiAmbe[AMBE_SIZE];
+            ::memset(uiAmbe, 0x00, sizeof(uiAmbe));
+            frames[0] = new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 0, 0);
+            frames[1] = new CDvLastFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 1, 0);
+        }
+        
+        // check validity of packets
+        if ( (frames[0] == NULL) || !(frames[0]->IsValid()) ||
+             (frames[1] == NULL) || !(frames[1]->IsValid()) )
+            
+        {
+            delete frames[0];
+            delete frames[1];
+            frames[0] = NULL;
+            frames[1] = NULL;
+        }
+        else
+        {
+            valid = true;
+        }
+    }
+    
+    // done
+    return valid;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// DV packet encoding helpers
+
+void CYsfProtocol::EncodeConnectAckPacket(CBuffer *Buffer) const
+{
+    uint8 tag[] = { 'Y','S','F','P','R','E','F','L','E','C','T','O','R',0x20 };
+
+    Buffer->Set(tag, sizeof(tag));
+}
+
+bool CYsfProtocol::EncodeDvHeaderPacket(const CDvHeaderPacket &Header, CBuffer *Buffer) const
+{
+    uint8 tag[]  = { 'Y','S','F','D' };
+    uint8 dest[] = { 'A','L','L',' ',' ',' ',' ',' ',' ',' ' };
+    char  sz[YSF_CALLSIGN_LENGTH];
+    uint8 fichd[YSF_FICH_LENGTH_BYTES];
+
+    // tag
+    Buffer->Set(tag, sizeof(tag));
+    // rpt1
+    ::memset(sz, ' ', sizeof(sz));
+    Header.GetRpt1Callsign().GetCallsignString(sz);
+    sz[::strlen(sz)] = ' ';
+    Buffer->Append((uint8 *)sz, YSF_CALLSIGN_LENGTH);
+    // my
+    ::memset(sz, ' ', sizeof(sz));
+    Header.GetMyCallsign().GetCallsignString(sz);
+    sz[::strlen(sz)] = ' ';
+    Buffer->Append((uint8 *)sz, YSF_CALLSIGN_LENGTH);
+    // dest
+    Buffer->Append(dest, 10);
+    // net frame counter
+    Buffer->Append((uint8)0x00);
+    // FS
+    Buffer->Append((uint8 *)YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES);
+    // FICH
+    CYSFFICH fich;
+    fich.setFI(YSF_FI_HEADER);
+    fich.setCS(2U);
+    //fich.setFN(Header.GetYsfPacketId());
+    fich.setFN(0U);
+    fich.setFT(7U);
+    fich.setDev(0U);
+    fich.setMR(YSF_MR_BUSY);
+    fich.setDT(YSF_DT_VD_MODE2);
+    fich.setSQL(0U);
+    fich.setSQ(0U);
+    fich.encode(fichd);
+    Buffer->Append(fichd, YSF_FICH_LENGTH_BYTES);
+    // payload
+    unsigned char csd1[20U], csd2[20U];
+    ::memset(csd1, '*', YSF_CALLSIGN_LENGTH);
+    ::memset(csd1 + YSF_CALLSIGN_LENGTH, ' ', YSF_CALLSIGN_LENGTH);
+    Header.GetMyCallsign().GetCallsignString(sz);
+    ::memcpy(csd1 + YSF_CALLSIGN_LENGTH, sz, ::strlen(sz));
+    ::memset(csd2, ' ', YSF_CALLSIGN_LENGTH + YSF_CALLSIGN_LENGTH);
+    CYSFPayload payload;
+    uint8 temp[120];
+    payload.writeHeader(temp, csd1, csd2);
+    Buffer->Append(temp+30, 120-30);
+     
+    // done
+    return true;
+}
+
+bool CYsfProtocol::EncodeDvPacket(const CDvHeaderPacket &Header, const CDvFramePacket *DvFrames, CBuffer *Buffer) const
+{
+    uint8 tag[]  = { 'Y','S','F','D' };
+    uint8 dest[] = { 'A','L','L',' ',' ',' ',' ',' ',' ',' ' };
+    uint8 gps[]  = { 0x52,0x22,0x61,0x5F,0x27,0x03,0x5E,0x20,0x20,0x20 };
+    char  sz[YSF_CALLSIGN_LENGTH];
+    uint8 fichd[YSF_FICH_LENGTH_BYTES];
+    
+     // tag
+    Buffer->Set(tag, sizeof(tag));
+    // rpt1
+    ::memset(sz, ' ', sizeof(sz));
+    Header.GetRpt1Callsign().GetCallsignString(sz);
+    sz[::strlen(sz)] = ' ';
+    Buffer->Append((uint8 *)sz, YSF_CALLSIGN_LENGTH);
+    // my
+    ::memset(sz, ' ', sizeof(sz));
+    Header.GetMyCallsign().GetCallsignString(sz);
+    sz[::strlen(sz)] = ' ';
+    Buffer->Append((uint8 *)sz, YSF_CALLSIGN_LENGTH);
+    // dest
+    Buffer->Append(dest, 10);
+    // net frame counter
+    Buffer->Append(DvFrames[0].GetYsfPacketFrameId());
+     // FS
+    Buffer->Append((uint8 *)YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES);
+    // FICH
+    CYSFFICH fich;
+    fich.setFI(YSF_FI_COMMUNICATIONS);
+    fich.setCS(2U);
+    fich.setFN(DvFrames[0].GetYsfPacketId());
+    fich.setFT(6U);
+    fich.setDev(0U);
+    fich.setMR(YSF_MR_BUSY);
+    fich.setDT(YSF_DT_VD_MODE2);
+    fich.setSQL(0U);
+    fich.setSQ(0U);
+    fich.encode(fichd);
+    Buffer->Append(fichd, YSF_FICH_LENGTH_BYTES);
+     // payload
+    CYSFPayload payload;
+    uint8 temp[120];
+    ::memset(temp, 0x00, sizeof(temp));
+    // DV
+    for ( int i = 0; i < 5; i++ )
+    {
+        CYsfUtils::EncodeVD2Vch((unsigned char *)DvFrames[i].GetAmbePlus(), temp+35+(18*i));
+    }
+    // data
+    switch (DvFrames[0].GetYsfPacketId())
+    {
+        case 0:
+            // Dest
+            payload.writeVDMode2Data(temp, (const unsigned char*)"**********");
+            break;
+        case 1:
+            // Src
+            ::memset(sz, ' ', sizeof(sz));
+            Header.GetMyCallsign().GetCallsignString(sz);
+            sz[::strlen(sz)] = ' ';
+            payload.writeVDMode2Data(temp, (const unsigned char*)sz);
+            break;
+        case 2:
+            // Down
+            ::memset(sz, ' ', sizeof(sz));
+            Header.GetRpt1Callsign().GetCallsignString(sz);
+            sz[::strlen(sz)] = ' ';
+            payload.writeVDMode2Data(temp, (const unsigned char*)sz);
+            break;
+        case 5:
+            // Rem3+4
+            // we need to provide a fake radioid for radios
+            // to display src callsign
+            payload.writeVDMode2Data(temp, (const unsigned char*)"     G0gBJ");
+            break;
+        case 6:
+            // DT1
+            // we need to issue a fake gps string with proper terminator
+            // and crc for radios to display src callsign
+            payload.writeVDMode2Data(temp, gps);
+            break;
+        default:
+            payload.writeVDMode2Data(temp, (const unsigned char*)"          ");
+            break;
+
+    }
+    Buffer->Append(temp+30, 120-30);
+
+    // done
+    return true;
+}
+
+bool CYsfProtocol::EncodeDvLastPacket(const CDvHeaderPacket &Header, CBuffer *Buffer) const
+{
+    uint8 tag[]  = { 'Y','S','F','D' };
+    uint8 dest[] = { 'A','L','L',' ',' ',' ',' ',' ',' ',' ' };
+    char  sz[YSF_CALLSIGN_LENGTH];
+    uint8 fichd[YSF_FICH_LENGTH_BYTES];
+    
+    // tag
+    Buffer->Set(tag, sizeof(tag));
+    // rpt1
+    ::memset(sz, ' ', sizeof(sz));
+    Header.GetRpt1Callsign().GetCallsignString(sz);
+    sz[::strlen(sz)] = ' ';
+    Buffer->Append((uint8 *)sz, YSF_CALLSIGN_LENGTH);
+    // my
+    ::memset(sz, ' ', sizeof(sz));
+    Header.GetMyCallsign().GetCallsignString(sz);
+    sz[::strlen(sz)] = ' ';
+    Buffer->Append((uint8 *)sz, YSF_CALLSIGN_LENGTH);
+    // dest
+    Buffer->Append(dest, 10);
+    // net frame counter
+    Buffer->Append((uint8)0x00);
+    // FS
+    Buffer->Append((uint8 *)YSF_SYNC_BYTES, YSF_SYNC_LENGTH_BYTES);
+    // FICH
+    CYSFFICH fich;
+    fich.setFI(YSF_FI_TERMINATOR);
+    fich.setCS(2U);
+    //fich.setFN(Header.GetYsfPacketId());
+    fich.setFN(0U);
+    fich.setFT(7U);
+    fich.setDev(0U);
+    fich.setMR(YSF_MR_BUSY);
+    fich.setDT(YSF_DT_VD_MODE2);
+    fich.setSQL(0U);
+    fich.setSQ(0U);
+    fich.encode(fichd);
+    Buffer->Append(fichd, YSF_FICH_LENGTH_BYTES);
+    // payload
+    unsigned char csd1[20U], csd2[20U];
+    ::memset(csd1, '*', YSF_CALLSIGN_LENGTH);
+    ::memset(csd1 + YSF_CALLSIGN_LENGTH, ' ', YSF_CALLSIGN_LENGTH);
+    Header.GetMyCallsign().GetCallsignString(sz);
+    ::memcpy(csd1 + YSF_CALLSIGN_LENGTH, sz, ::strlen(sz));
+    ::memset(csd2, ' ', YSF_CALLSIGN_LENGTH + YSF_CALLSIGN_LENGTH);
+    CYSFPayload payload;
+    uint8 temp[120];
+    payload.writeHeader(temp, csd1, csd2);
+    Buffer->Append(temp+30, 120-30);
+    
+    // done
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Wires-X packet decoding helpers
+
+bool CYsfProtocol::IsValidwirexPacket(const CBuffer &Buffer, CYSFFICH *Fich, CCallsign *Callsign, int *Cmd, int *Arg)
+{
+    uint8 tag[] = { 'Y','S','F','D' };
+    uint8 DX_REQ[]    = {0x5DU, 0x71U, 0x5FU};
+    uint8 CONN_REQ[]  = {0x5DU, 0x23U, 0x5FU};
+    uint8 DISC_REQ[]  = {0x5DU, 0x2AU, 0x5FU};
+    uint8 ALL_REQ[]   = {0x5DU, 0x66U, 0x5FU};
+    uint8 command[300];
+    CYSFPayload payload;
+    bool valid = false;
+
+    if ( (Buffer.size() == 155) && (Buffer.Compare(tag, sizeof(tag)) == 0) )
+    {
+        // decode YSH fich
+        if ( Fich->decode(&(Buffer.data()[40])) )
+        {
+            //std::cout << (int)Fich->getDT() << ","
+            //          << (int)Fich->getFI() << ","
+            //          << (int)Fich->getFN() << ","
+            //          << (int)Fich->getFT()
+            //          << std::endl;
+            valid = (Fich->getDT() == YSF_DT_DATA_FR_MODE);
+            valid &= (Fich->getFI() == YSF_FI_COMMUNICATIONS);
+            if ( valid )
+            {
+                // get callsign
+                Callsign->SetCallsign(&(Buffer.data()[4]), CALLSIGN_LEN, false);
+                Callsign->SetModule(YSF_MODULE_ID);
+                // decode payload
+                if ( Fich->getFN() == 0U )
+                {
+                    valid = false;
+                }
+                else if ( Fich->getFN() == 1U )
+                {
+                    valid &= payload.readDataFRModeData2(&(Buffer.data()[35]), command + 0U);
+                }
+                else
+                {
+                    valid &= payload.readDataFRModeData1(&(Buffer.data()[35]), command + (Fich->getFN() - 1U) * 20U + 0U);
+                    if ( valid )
+                    {
+                        valid &= payload.readDataFRModeData2(&(Buffer.data()[35]), command + (Fich->getFN() - 1U) * 20U + 20U);
+                    }
+                }
+                // check crc if end found
+                if ( Fich->getFN() == Fich->getFT() )
+                {
+                    valid = false;
+                    // Find the end marker
+                    for (unsigned int i = Fich->getFN() * 20U; i > 0U; i--)
+                    {
+                        if (command[i] == 0x03U)
+                        {
+                            unsigned char crc = CCRC::addCRC(command, i + 1U);
+                            if (crc == command[i + 1U])
+                                valid = true;
+                            break;
+                        }
+                    }
+                }
+                // and crack the command
+                if ( valid )
+                {
+                    // get argument
+                    char buffer[4U];
+                    ::memcpy(buffer, command + 5U + 2U, 3U);
+                    buffer[3U] = 0x00U;
+                    *Arg = ::atoi(buffer);
+                    // and decode command
+                    if (::memcmp(command + 1U, DX_REQ, 3U) == 0)
+                    {
+                        *Cmd = WIRESX_CMD_DX_REQ;
+                        *Arg = 0;
+                     }
+                    else if (::memcmp(command + 1U, ALL_REQ, 3U) == 0)
+                    {
+                        // argument is start index of list
+                       if ( *Arg > 0 )
+                            (*Arg)--;
+                        // check if all or search
+                        if ( ::memcmp(command + 5U, "01", 2) == 0 )
+                        {
+                             *Cmd = WIRESX_CMD_ALL_REQ;
+                        }
+                        else if ( ::memcmp(command + 5U, "11", 2) == 0 )
+                        {
+                             *Cmd = WIRESX_CMD_SEARCH_REQ;
+                        }
+                     }
+                    else if (::memcmp(command + 1U, CONN_REQ, 3U) == 0)
+                    {
+                        *Cmd = WIRESX_CMD_CONN_REQ;
+                    }
+                    else if (::memcmp(command + 1U, DISC_REQ, 3U) == 0)
+                    {
+                        *Cmd = WIRESX_CMD_DISC_REQ;
+                        *Arg = 0;
+                    }
+                    else
+                    {
+                        std::cout << "Wires-X unknown command" << std::endl;
+                        *Cmd = WIRESX_CMD_UNKNOWN;
+                        *Arg = 0;
+                        valid = false;
+                    }
+                }
+            }
+        }
+    }
+    return valid;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// uiStreamId helpers
+
+
+// uiStreamId helpers
+uint32 CYsfProtocol::IpToStreamId(const CIp &ip) const
+{
+    return ip.GetAddr() ^ (uint32)(MAKEDWORD(ip.GetPort(), ip.GetPort()));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// debug
+
+#ifdef DEBUG_DUMPFILE
+bool CYsfProtocol::DebugTestDecodePacket(const CBuffer &Buffer)
+{
+    uint8 tag[] = { 'Y','S','F','D' };
+    static uint8 command[4098];
+    static int len;
+    CYSFFICH Fich;
+    CYSFPayload payload;
+    CBuffer dump;
+    bool valid = false;
+    
+    if ( (Buffer.size() == 155) && (Buffer.Compare(tag, sizeof(tag)) == 0) )
+    {
+        // decode YSH fich
+        if ( Fich.decode(&(Buffer.data()[40])) )
+        {
+            std::cout << (int)Fich.getDT() << ","
+                      << (int)Fich.getFI() << ","
+                      << (int)Fich.getBN() << ","
+                      << (int)Fich.getBT() << ","
+                      << (int)Fich.getFN() << ","
+                      << (int)Fich.getFT() << " : ";
+            
+            switch ( Fich.getFI() )
+            {
+                case YSF_FI_HEADER:
+                    len = 0;
+                    ::memset(command, 0x00, sizeof(command));
+                    std::cout << "Header" << std::endl;
+                    break;
+                case YSF_FI_TERMINATOR:
+                    std::cout << "Trailer" << std::endl;
+                    std::cout << "length of payload : " << len << std::endl;
+                    dump.Set(command, len);
+                    dump.DebugDump(g_Reflector.m_DebugFile);
+                    dump.DebugDumpAscii(g_Reflector.m_DebugFile);
+                    break;
+                case YSF_FI_COMMUNICATIONS:
+                    if ( Fich.getDT() == YSF_DT_DATA_FR_MODE )
+                    {
+                        valid = payload.readDataFRModeData1(&(Buffer.data()[35]), command + len);
+                        len += 20;
+                        valid &= payload.readDataFRModeData2(&(Buffer.data()[35]), command + len);
+                        len += 20;
+                        std::cout << "decoded ok" << std::endl;
+                    }
+                    break;
+            }
+        }
+        else
+        {
+            std::cout << "invalid fich in packet" << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << "invalid size packet" << std::endl;
+    }
+    return valid;
+}
+#endif
+
+
+bool CYsfProtocol::DebugDumpHeaderPacket(const CBuffer &Buffer)
+{
+    bool ok;
+    CYSFFICH fich;
+    CYSFPayload payload;
+    uint8 data[200];
+
+    :: memset(data, 0, sizeof(data));
+    
+
+    ok = IsValidDvPacket(Buffer, &fich);
+    if ( ok && (fich.getFI() == YSF_FI_HEADER) )
+    {
+        ok &= payload.processHeaderData((unsigned char *)&(Buffer.data()[35]));
+    }
+    
+    std::cout << "HD-" <<(ok ? "ok " : "xx ") << "src: " << payload.getSource() << "dest: " << payload.getDest() << std::endl;
+
+    return ok;
+}
+
+bool CYsfProtocol::DebugDumpDvPacket(const CBuffer &Buffer)
+{
+    bool ok;
+    CYSFFICH fich;
+    CYSFPayload payload;
+    uint8 data[200];
+
+    :: memset(data, 0, sizeof(data));
+
+    ok = IsValidDvPacket(Buffer, &fich);
+    if ( ok && (fich.getFI() == YSF_FI_COMMUNICATIONS) )
+    {
+        ok &= payload.readVDMode2Data(&(Buffer.data()[35]), data);
+    }
+
+    std::cout << "DV-" <<(ok ? "ok " : "xx ") << "FN:" << (int)fich.getFN() << "  payload: " << (char *)data << std::endl;
+ 
+    return ok;
+}
+
+bool CYsfProtocol::DebugDumpLastDvPacket(const CBuffer &Buffer)
+{
+    bool ok;
+    CYSFFICH fich;
+    CYSFPayload payload;
+    uint8 data[200];
+
+    :: memset(data, 0, sizeof(data));
+    
+
+    ok = IsValidDvPacket(Buffer, &fich);
+    if ( ok && (fich.getFI() == YSF_FI_TERMINATOR) )
+    {
+        ok &= payload.processHeaderData((unsigned char *)&(Buffer.data()[35]));
+    }
+    
+    std::cout << "TC-" <<(ok ? "ok " : "xx ") << "src: " << payload.getSource() << "dest: " << payload.getDest() << std::endl;
+
+    return ok;
+}
diff --git a/src/cysfprotocol.h b/src/cysfprotocol.h
new file mode 100644
index 0000000..fb06184
--- /dev/null
+++ b/src/cysfprotocol.h
@@ -0,0 +1,137 @@
+//
+//  cysfprotocol.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 20/05/2018.
+//  Copyright © 2015 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+
+#ifndef cysfprotocol_h
+#define cysfprotocol_h
+
+
+#include "ctimepoint.h"
+#include "cprotocol.h"
+#include "cdvheaderpacket.h"
+#include "cdvframepacket.h"
+#include "cdvlastframepacket.h"
+#include "ysfdefines.h"
+#include "cysffich.h"
+#include "cwiresxinfo.h"
+#include "cwiresxcmdhandler.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// define
+
+
+// Wires-X commands
+#define WIRESX_CMD_UNKNOWN          0
+#define WIRESX_CMD_DX_REQ           1
+#define WIRESX_CMD_ALL_REQ          2
+#define WIRESX_CMD_SEARCH_REQ       3
+#define WIRESX_CMD_CONN_REQ         4
+#define WIRESX_CMD_DISC_REQ         5
+
+// YSF Module ID
+#define YSF_MODULE_ID             'B'
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CYsfStreamCacheItem
+{
+public:
+    CYsfStreamCacheItem()     {}
+    ~CYsfStreamCacheItem()    {}
+    
+    CDvHeaderPacket m_dvHeader;
+    CDvFramePacket  m_dvFrames[5];
+
+    //uint8  m_uiSeqId;
+};
+
+class CYsfProtocol : public CProtocol
+{
+public:
+    // constructor
+    CYsfProtocol();
+    
+    // destructor
+    virtual ~CYsfProtocol() {};
+    
+    // initialization
+    bool Init(void);
+    void Close(void);
+    
+    // task
+    void Task(void);
+    
+protected:
+    // queue helper
+    void HandleQueue(void);
+    
+    // keepalive helpers
+    void HandleKeepalives(void);
+    
+    // stream helpers
+    bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &);
+    
+    // DV packet decoding helpers
+    bool IsValidConnectPacket(const CBuffer &, CCallsign *);
+    //bool IsValidDisconnectPacket(const CBuffer &, CCallsign *);
+    bool IsValidDvPacket(const CBuffer &, CYSFFICH *);
+    bool IsValidDvHeaderPacket(const CIp &, const CYSFFICH &, const CBuffer &, CDvHeaderPacket **, CDvFramePacket **);
+    bool IsValidDvFramePacket(const CIp &, const CYSFFICH &, const CBuffer &, CDvFramePacket **);
+    bool IsValidDvLastFramePacket(const CIp &, const CYSFFICH &, const CBuffer &, CDvFramePacket **);
+    
+    // DV packet encoding helpers
+    void EncodeConnectAckPacket(CBuffer *) const;
+    //void EncodeConnectNackPacket(const CCallsign &, char, CBuffer *);
+    //void EncodeDisconnectPacket(CBuffer *, CClient *);
+    bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer *) const;
+    bool EncodeDvPacket(const CDvHeaderPacket &, const CDvFramePacket *, CBuffer *) const;
+    bool EncodeDvLastPacket(const CDvHeaderPacket &, CBuffer *) const;
+
+    // Wires-X packet decoding helpers
+    bool IsValidwirexPacket(const CBuffer &, CYSFFICH *, CCallsign *, int *, int*);
+    
+    // uiStreamId helpers
+    uint32 IpToStreamId(const CIp &) const;
+    
+    // debug
+    bool DebugTestDecodePacket(const CBuffer &);
+    bool DebugDumpHeaderPacket(const CBuffer &);
+    bool DebugDumpDvPacket(const CBuffer &);
+    bool DebugDumpLastDvPacket(const CBuffer &);
+    
+protected:
+    // for keep alive
+    CTimePoint          m_LastKeepaliveTime;
+    
+    // for queue header caches
+    std::array<CYsfStreamCacheItem, NB_OF_MODULES>    m_StreamsCache;
+    
+    // for wires-x
+    CWiresxCmdHandler   m_WiresxCmdHandler;
+    unsigned char m_seqNo;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfprotocol_h */
diff --git a/src/cysfutils.cpp b/src/cysfutils.cpp
new file mode 100644
index 0000000..914f684
--- /dev/null
+++ b/src/cysfutils.cpp
@@ -0,0 +1,641 @@
+//
+//  cysfutils.cpp
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 14/04/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//   Copyright (C) 2016,2017 by Jonathan Naylor G4KLX
+//  Copyright (C) 2018 by Andy Uribe CA6JAU
+//  Copyright (C) 2018 by Manuel Sanchez EA7EE
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#include "main.h"
+#include <string.h>
+#include "ysfdefines.h"
+#include "cysfutils.h"
+#include "cgolay24128.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// constants & defines
+
+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 DMR_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 DMR_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 DMR_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 BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
+
+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};
+
+////////////////////////////////////////////////////////////////////////////////////////
+// macros
+
+#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])
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+
+void CYsfUtils::DecodeVD2Vchs(uint8 *data, uint8 **ambe)
+{
+    int frame = 0;
+    
+    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;;
+        }
+        
+        // convert to ambe2plus
+        unsigned char v_dmr[9U];
+        
+        unsigned int a = CGolay24128::encode24128(dat_a);
+        unsigned int p = PRNG_TABLE[dat_a] >> 1;
+        unsigned int b = CGolay24128::encode23127(dat_b) >> 1;
+        b ^= p;
+        
+        unsigned int MASK = 0x800000U;
+        for (unsigned int i = 0U; i < 24U; i++, MASK >>= 1) {
+            unsigned int aPos = DMR_A_TABLE[i];
+            WRITE_BIT(v_dmr, aPos, a & MASK);
+        }
+        
+        MASK = 0x400000U;
+        for (unsigned int i = 0U; i < 23U; i++, MASK >>= 1) {
+            unsigned int bPos = DMR_B_TABLE[i];
+            WRITE_BIT(v_dmr, bPos, b & MASK);
+        }
+        
+        MASK = 0x1000000U;
+        for (unsigned int i = 0U; i < 25U; i++, MASK >>= 1) {
+            unsigned int cPos = DMR_C_TABLE[i];
+            WRITE_BIT(v_dmr, cPos, dat_c & MASK);
+        }
+        
+        ::memcpy(ambe[frame++], v_dmr, 9);
+    }
+}
+
+void CYsfUtils::EncodeVD2Vch(uint8 *ambe, uint8 *data)
+{
+    // convert from ambe2plus
+    unsigned int a = 0U;
+    unsigned int MASK = 0x800000U;
+    for (unsigned int i = 0U; i < 24U; i++, MASK >>= 1) {
+        unsigned int aPos = DMR_A_TABLE[i];
+        
+        if (READ_BIT(ambe, aPos))
+            a |= MASK;
+    }
+    
+    unsigned int b = 0U;
+    MASK = 0x400000U;
+    for (unsigned int i = 0U; i < 23U; i++, MASK >>= 1) {
+        unsigned int bPos = DMR_B_TABLE[i];
+        
+        if (READ_BIT(ambe, bPos))
+            b |= MASK;
+    }
+    
+    unsigned int dat_c = 0U;
+    MASK = 0x1000000U;
+    for (unsigned int i = 0U; i < 25U; i++, MASK >>= 1) {
+        unsigned int cPos = DMR_C_TABLE[i];
+        
+        if (READ_BIT(ambe, cPos))
+            dat_c |= MASK;
+     }
+    
+    // and to vch
+    unsigned char vch[13U];
+    unsigned char ysfFrame[13U];
+    ::memset(vch, 0U, 13U);
+    ::memset(ysfFrame, 0, 13U);
+    
+    unsigned int dat_a = a >> 12;
+    
+    // The PRNG
+    b ^= (PRNG_TABLE[dat_a] >> 1);
+    
+    unsigned int dat_b = b >> 11;
+    
+    for (unsigned int i = 0U; i < 12U; i++) {
+        bool s = (dat_a << (20U + i)) & 0x80000000U;
+        WRITE_BIT(vch, 3*i + 0U, s);
+        WRITE_BIT(vch, 3*i + 1U, s);
+        WRITE_BIT(vch, 3*i + 2U, s);
+    }
+    
+    for (unsigned int i = 0U; i < 12U; i++) {
+        bool s = (dat_b << (20U + i)) & 0x80000000U;
+        WRITE_BIT(vch, 3*(i + 12U) + 0U, s);
+        WRITE_BIT(vch, 3*(i + 12U) + 1U, s);
+        WRITE_BIT(vch, 3*(i + 12U) + 2U, s);
+    }
+    
+    for (unsigned int i = 0U; i < 3U; i++) {
+        bool s = (dat_c << (7U + i)) & 0x80000000U;
+        WRITE_BIT(vch, 3*(i + 24U) + 0U, s);
+        WRITE_BIT(vch, 3*(i + 24U) + 1U, s);
+        WRITE_BIT(vch, 3*(i + 24U) + 2U, s);
+    }
+    
+    for (unsigned int i = 0U; i < 22U; i++) {
+        bool s = (dat_c << (10U + i)) & 0x80000000U;
+        WRITE_BIT(vch, i + 81U, s);
+    }
+    
+    WRITE_BIT(vch, 103U, 0U);
+    
+    // Scramble
+    for (unsigned int i = 0U; i < 13U; i++)
+        vch[i] ^= WHITENING_DATA[i];
+    
+    // Interleave
+    for (unsigned int i = 0U; i < 104U; i++) {
+        unsigned int n = INTERLEAVE_TABLE_26_4[i];
+        bool s = READ_BIT(vch, i);
+        WRITE_BIT(ysfFrame, n, s);
+    }
+    
+    ::memcpy(data, ysfFrame, 13U);
+ }
diff --git a/src/cysfutils.h b/src/cysfutils.h
new file mode 100644
index 0000000..90a9a01
--- /dev/null
+++ b/src/cysfutils.h
@@ -0,0 +1,53 @@
+//
+//  cysfutils.h
+//  xlxd
+//
+//  Created by Jean-Luc Deltombe (LX3JL) on 14/04/2019.
+//  Copyright © 2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//  Copyright (C) 2016,2017 by Jonathan Naylor G4KLX
+//  Copyright (C) 2018 by Andy Uribe CA6JAU
+//  Copyright (C) 2018 by Manuel Sanchez EA7EE
+//
+// ----------------------------------------------------------------------------
+//    This file is part of xlxd.
+//
+//    xlxd 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 3 of the License, or
+//    (at your option) any later version.
+//
+//    xlxd 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
+// ----------------------------------------------------------------------------
+
+#ifndef cysfutils_h
+#define cysfutils_h
+
+////////////////////////////////////////////////////////////////////////////////////////
+// class
+
+class CYsfUtils
+{
+public:
+    // constructor
+    CYsfUtils() {};
+    
+    // destructor
+    virtual ~CYsfUtils() {};
+    
+    // operation
+    static void DecodeVD2Vchs(uint8 *, uint8 **);
+    static void EncodeVD2Vch(uint8 *, uint8 *);
+
+    
+protected:
+    // data
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+#endif /* cysfutils_h */
diff --git a/src/main.cpp b/src/main.cpp
index 154a53b..5bd21fd 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -125,7 +125,6 @@ int main(int argc, const char * argv[])
         std::cin.get();
 #ifdef DEBUG_DUMPFILE
         g_Reflector.m_DebugFile.close();
-        g_Reflector.m_DebugFile.open("/Users/jeanluc/Desktop/dmrdebug.txt");
 #endif
     }
 #endif
diff --git a/src/main.h b/src/main.h
index fa7acab..a59d6c1 100644
--- a/src/main.h
+++ b/src/main.h
@@ -3,7 +3,7 @@
 //  xlxd
 //
 //  Created by Jean-Luc Deltombe (LX3JL) on 31/10/2015.
-//  Copyright © 2015 Jean-Luc Deltombe (LX3JL). All rights reserved.
+//  Copyright © 2015-2019 Jean-Luc Deltombe (LX3JL). All rights reserved.
 //
 // ----------------------------------------------------------------------------
 //    This file is part of xlxd.
@@ -48,14 +48,16 @@
 // version -----------------------------------------------------
 
 #define VERSION_MAJOR                   2
-#define VERSION_MINOR                   2
-#define VERSION_REVISION                2
+#define VERSION_MINOR                   3
+#define VERSION_REVISION                1
 
 // global ------------------------------------------------------
 
 #define RUN_AS_DAEMON
 #define JSON_MONITOR
-//#define NO_ERROR_ON_XML_OPEN_FAIL
+
+// debug -------------------------------------------------------
+//#define DEBUG_NO_ERROR_ON_XML_OPEN_FAIL
 //#define DEBUG_DUMPFILE
 
 // reflector ---------------------------------------------------
@@ -65,7 +67,7 @@
 
 // protocols ---------------------------------------------------
 
-#define NB_OF_PROTOCOLS                 6
+#define NB_OF_PROTOCOLS                 7
 
 #define PROTOCOL_ANY                    -1
 #define PROTOCOL_NONE                   0
@@ -75,6 +77,7 @@
 #define PROTOCOL_XLX                    4
 #define PROTOCOL_DMRPLUS                5
 #define PROTOCOL_DMRMMDVM               6
+#define PROTOCOL_YSF                    7
 
 // DExtra
 #define DEXTRA_PORT                     30001                               // UDP port
@@ -111,6 +114,14 @@
 #define DMRMMDVM_REFLECTOR_SLOT         DMR_SLOT2
 #define DMRMMDVM_REFLECTOR_COLOUR       1
 
+// YSF
+#define YSF_PORT                        42000                               // UDP port
+#define YSF_KEEPALIVE_PERIOD            3                                   // in seconds
+#define YSF_KEEPALIVE_TIMEOUT           (YSF_KEEPALIVE_PERIOD*10)           // in seconds
+#define YSF_DEFAULT_NODE_TX_FREQ        437000000                           // in Hz
+#define YSF_DEFAULT_NODE_RX_FREQ        437000000                           // in Hz
+
+
 // Transcoder server --------------------------------------------
 
 #define TRANSCODER_PORT                 10100                               // UDP port
@@ -120,9 +131,9 @@
 
 // codec --------------------------------------------------------
 
-#define CODEC_NONE          0
-#define CODEC_AMBEPLUS      1                                               // DStar
-#define CODEC_AMBE2PLUS     2                                               // DMR
+#define CODEC_NONE                      0
+#define CODEC_AMBEPLUS                  1                                   // DStar
+#define CODEC_AMBE2PLUS                 2                                   // DMR
 
 
 // DMRid database -----------------------------------------------
@@ -131,6 +142,11 @@
 #define DMRIDDB_PATH                    "/xlxd/dmrid.dat"                   // local file path
 #define DMRIDDB_REFRESH_RATE            180                                 // in minutes
 
+// Wires-X node database ----------------------------------------
+
+#define YSFNODEDB_USE_RLX_SERVER        1                                   // 1 = use http, 0 = use local file
+#define YSFNODEDB_PATH                  "/xlxd/ysfnode.dat"                 // local file path
+#define YSFNODEDB_REFRESH_RATE          180                                 // in minutes
 
 // xml & json reporting -----------------------------------------
 
@@ -189,6 +205,14 @@ extern CGateKeeper g_GateKeeper;
     extern CDmridDirFile   g_DmridDir;
 #endif
 
+#if (YSFNODEDB_USE_RLX_SERVER == 1)
+    class CYsfNodeDirHttp;
+    extern CYsfNodeDirHttp   g_YsfNodeDir;
+#else
+    class CYsfNodeDirFile;
+    extern CYsfNodeDirFile   g_YsfNodeDir;
+#endif
+
 class CTranscoder;
 extern CTranscoder g_Transcoder;
 
diff --git a/src/ysfdefines.h b/src/ysfdefines.h
new file mode 100644
index 0000000..3734984
--- /dev/null
+++ b/src/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