diff --git a/lib/qra/qra64/Makefile.Win b/lib/qra/qra64/Makefile.Win
deleted file mode 100644
index 7bd10c2d1..000000000
--- a/lib/qra/qra64/Makefile.Win
+++ /dev/null
@@ -1,30 +0,0 @@
-FC = gfortran
-CC = gcc
-CFLAGS = -O2 -Wall -I. -D_WIN32
-
-# Default rules
-%.o: %.c
-	${CC} ${CFLAGS} -c $<
-%.o: %.f
-	${FC} ${FFLAGS} -c $<
-%.o: %.F
-	${FC} ${FFLAGS} -c $<
-%.o: %.f90
-	${FC} ${FFLAGS} -c $<
-%.o: %.F90
-	${FC} ${FFLAGS} -c $<
-
-all:	qra64.exe
-
-OBJS1 = main.o qra64.o
-qra64.exe: $(OBJS1)
-	${CC} -o qra64.exe $(OBJS1) ../qracodes/libqra64.a -lm
-
-OBJS2 = qra64sim.o options.o wavhdr.o 
-qra64sim.exe: $(OBJS2)
-	${FC} -o qra64sim.exe $(OBJS2) ../qracodes/libqra64.a -lm
-
-.PHONY : clean
-
-clean:
-	$(RM) *.o qra64.exe qra64sim.exe
diff --git a/lib/qra/qra64/fadengauss.c b/lib/qra/qra64/fadengauss.c
deleted file mode 100644
index c229626f4..000000000
--- a/lib/qra/qra64/fadengauss.c
+++ /dev/null
@@ -1,302 +0,0 @@
-// Gaussian energy fading tables for QRA64
-static const int glen_tab_gauss[64] = {
-  2,   2,   2,   2,   2,   2,   2,   2, 
-  2,   2,   2,   2,   2,   2,   2,   2, 
-  3,   3,   3,   3,   3,   3,   3,   3, 
-  4,   4,   4,   4,   5,   5,   5,   6, 
-  6,   6,   7,   7,   8,   8,   9,  10, 
- 10,  11,  12,  13,  14,  15,  17,  18, 
- 19,  21,  23,  25,  27,  29,  32,  34, 
- 37,  41,  44,  48,  52,  57,  62,  65
-};
-static const float ggauss1[2] = {
-0.0296f, 0.9101f
-};
-static const float ggauss2[2] = {
-0.0350f, 0.8954f
-};
-static const float ggauss3[2] = {
-0.0411f, 0.8787f
-};
-static const float ggauss4[2] = {
-0.0483f, 0.8598f
-};
-static const float ggauss5[2] = {
-0.0566f, 0.8387f
-};
-static const float ggauss6[2] = {
-0.0660f, 0.8154f
-};
-static const float ggauss7[2] = {
-0.0767f, 0.7898f
-};
-static const float ggauss8[2] = {
-0.0886f, 0.7621f
-};
-static const float ggauss9[2] = {
-0.1017f, 0.7325f
-};
-static const float ggauss10[2] = {
-0.1159f, 0.7012f
-};
-static const float ggauss11[2] = {
-0.1310f, 0.6687f
-};
-static const float ggauss12[2] = {
-0.1465f, 0.6352f
-};
-static const float ggauss13[2] = {
-0.1621f, 0.6013f
-};
-static const float ggauss14[2] = {
-0.1771f, 0.5674f
-};
-static const float ggauss15[2] = {
-0.1911f, 0.5339f
-};
-static const float ggauss16[2] = {
-0.2034f, 0.5010f
-};
-static const float ggauss17[3] = {
-0.0299f, 0.2135f, 0.4690f
-};
-static const float ggauss18[3] = {
-0.0369f, 0.2212f, 0.4383f
-};
-static const float ggauss19[3] = {
-0.0454f, 0.2263f, 0.4088f
-};
-static const float ggauss20[3] = {
-0.0552f, 0.2286f, 0.3806f
-};
-static const float ggauss21[3] = {
-0.0658f, 0.2284f, 0.3539f
-};
-static const float ggauss22[3] = {
-0.0766f, 0.2258f, 0.3287f
-};
-static const float ggauss23[3] = {
-0.0869f, 0.2212f, 0.3049f
-};
-static const float ggauss24[3] = {
-0.0962f, 0.2148f, 0.2826f
-};
-static const float ggauss25[4] = {
-0.0351f, 0.1041f, 0.2071f, 0.2616f
-};
-static const float ggauss26[4] = {
-0.0429f, 0.1102f, 0.1984f, 0.2420f
-};
-static const float ggauss27[4] = {
-0.0508f, 0.1145f, 0.1890f, 0.2237f
-};
-static const float ggauss28[4] = {
-0.0582f, 0.1169f, 0.1791f, 0.2067f
-};
-static const float ggauss29[5] = {
-0.0289f, 0.0648f, 0.1176f, 0.1689f, 0.1908f
-};
-static const float ggauss30[5] = {
-0.0351f, 0.0703f, 0.1168f, 0.1588f, 0.1760f
-};
-static const float ggauss31[5] = {
-0.0411f, 0.0745f, 0.1146f, 0.1488f, 0.1623f
-};
-static const float ggauss32[6] = {
-0.0246f, 0.0466f, 0.0773f, 0.1115f, 0.1390f, 0.1497f
-};
-static const float ggauss33[6] = {
-0.0297f, 0.0512f, 0.0788f, 0.1075f, 0.1295f, 0.1379f
-};
-static const float ggauss34[6] = {
-0.0345f, 0.0549f, 0.0791f, 0.1029f, 0.1205f, 0.1270f
-};
-static const float ggauss35[7] = {
-0.0240f, 0.0387f, 0.0575f, 0.0784f, 0.0979f, 0.1118f, 0.1169f
-};
-static const float ggauss36[7] = {
-0.0281f, 0.0422f, 0.0590f, 0.0767f, 0.0926f, 0.1037f, 0.1076f
-};
-static const float ggauss37[8] = {
-0.0212f, 0.0318f, 0.0449f, 0.0596f, 0.0744f, 0.0872f, 0.0960f, 0.0991f
-};
-static const float ggauss38[8] = {
-0.0247f, 0.0348f, 0.0467f, 0.0593f, 0.0716f, 0.0819f, 0.0887f, 0.0911f
-};
-static const float ggauss39[9] = {
-0.0199f, 0.0278f, 0.0372f, 0.0476f, 0.0584f, 0.0684f, 0.0766f, 0.0819f, 
-0.0838f
-};
-static const float ggauss40[10] = {
-0.0166f, 0.0228f, 0.0303f, 0.0388f, 0.0478f, 0.0568f, 0.0649f, 0.0714f, 
-0.0756f, 0.0771f
-};
-static const float ggauss41[10] = {
-0.0193f, 0.0254f, 0.0322f, 0.0397f, 0.0474f, 0.0548f, 0.0613f, 0.0664f, 
-0.0697f, 0.0709f
-};
-static const float ggauss42[11] = {
-0.0168f, 0.0217f, 0.0273f, 0.0335f, 0.0399f, 0.0464f, 0.0524f, 0.0576f, 
-0.0617f, 0.0643f, 0.0651f
-};
-static const float ggauss43[12] = {
-0.0151f, 0.0191f, 0.0237f, 0.0288f, 0.0342f, 0.0396f, 0.0449f, 0.0498f, 
-0.0540f, 0.0572f, 0.0592f, 0.0599f
-};
-static const float ggauss44[13] = {
-0.0138f, 0.0171f, 0.0210f, 0.0252f, 0.0297f, 0.0343f, 0.0388f, 0.0432f, 
-0.0471f, 0.0504f, 0.0529f, 0.0545f, 0.0550f
-};
-static const float ggauss45[14] = {
-0.0128f, 0.0157f, 0.0189f, 0.0224f, 0.0261f, 0.0300f, 0.0339f, 0.0377f, 
-0.0412f, 0.0444f, 0.0470f, 0.0489f, 0.0501f, 0.0505f
-};
-static const float ggauss46[15] = {
-0.0121f, 0.0146f, 0.0173f, 0.0202f, 0.0234f, 0.0266f, 0.0299f, 0.0332f, 
-0.0363f, 0.0391f, 0.0416f, 0.0437f, 0.0452f, 0.0461f, 0.0464f
-};
-static const float ggauss47[17] = {
-0.0097f, 0.0116f, 0.0138f, 0.0161f, 0.0186f, 0.0212f, 0.0239f, 0.0267f, 
-0.0294f, 0.0321f, 0.0346f, 0.0369f, 0.0389f, 0.0405f, 0.0417f, 0.0424f, 
-0.0427f
-};
-static const float ggauss48[18] = {
-0.0096f, 0.0113f, 0.0131f, 0.0151f, 0.0172f, 0.0194f, 0.0217f, 0.0241f, 
-0.0264f, 0.0287f, 0.0308f, 0.0329f, 0.0347f, 0.0362f, 0.0375f, 0.0384f, 
-0.0390f, 0.0392f
-};
-static const float ggauss49[19] = {
-0.0095f, 0.0110f, 0.0126f, 0.0143f, 0.0161f, 0.0180f, 0.0199f, 0.0219f, 
-0.0239f, 0.0258f, 0.0277f, 0.0294f, 0.0310f, 0.0325f, 0.0337f, 0.0347f, 
-0.0354f, 0.0358f, 0.0360f
-};
-static const float ggauss50[21] = {
-0.0083f, 0.0095f, 0.0108f, 0.0122f, 0.0136f, 0.0152f, 0.0168f, 0.0184f, 
-0.0201f, 0.0217f, 0.0234f, 0.0250f, 0.0265f, 0.0279f, 0.0292f, 0.0303f, 
-0.0313f, 0.0320f, 0.0326f, 0.0329f, 0.0330f
-};
-static const float ggauss51[23] = {
-0.0074f, 0.0084f, 0.0095f, 0.0106f, 0.0118f, 0.0131f, 0.0144f, 0.0157f, 
-0.0171f, 0.0185f, 0.0199f, 0.0213f, 0.0227f, 0.0240f, 0.0252f, 0.0263f, 
-0.0273f, 0.0282f, 0.0290f, 0.0296f, 0.0300f, 0.0303f, 0.0303f
-};
-static const float ggauss52[25] = {
-0.0068f, 0.0076f, 0.0085f, 0.0094f, 0.0104f, 0.0115f, 0.0126f, 0.0137f, 
-0.0149f, 0.0160f, 0.0172f, 0.0184f, 0.0196f, 0.0207f, 0.0218f, 0.0228f, 
-0.0238f, 0.0247f, 0.0255f, 0.0262f, 0.0268f, 0.0273f, 0.0276f, 0.0278f, 
-0.0279f
-};
-static const float ggauss53[27] = {
-0.0063f, 0.0070f, 0.0078f, 0.0086f, 0.0094f, 0.0103f, 0.0112f, 0.0121f, 
-0.0131f, 0.0141f, 0.0151f, 0.0161f, 0.0170f, 0.0180f, 0.0190f, 0.0199f, 
-0.0208f, 0.0216f, 0.0224f, 0.0231f, 0.0237f, 0.0243f, 0.0247f, 0.0251f, 
-0.0254f, 0.0255f, 0.0256f
-};
-static const float ggauss54[29] = {
-0.0060f, 0.0066f, 0.0072f, 0.0079f, 0.0086f, 0.0093f, 0.0101f, 0.0109f, 
-0.0117f, 0.0125f, 0.0133f, 0.0142f, 0.0150f, 0.0159f, 0.0167f, 0.0175f, 
-0.0183f, 0.0190f, 0.0197f, 0.0204f, 0.0210f, 0.0216f, 0.0221f, 0.0225f, 
-0.0228f, 0.0231f, 0.0233f, 0.0234f, 0.0235f
-};
-static const float ggauss55[32] = {
-0.0053f, 0.0058f, 0.0063f, 0.0068f, 0.0074f, 0.0080f, 0.0086f, 0.0093f, 
-0.0099f, 0.0106f, 0.0113f, 0.0120f, 0.0127f, 0.0134f, 0.0141f, 0.0148f, 
-0.0155f, 0.0162f, 0.0168f, 0.0174f, 0.0180f, 0.0186f, 0.0191f, 0.0196f, 
-0.0201f, 0.0204f, 0.0208f, 0.0211f, 0.0213f, 0.0214f, 0.0215f, 0.0216f
-};
-static const float ggauss56[34] = {
-0.0052f, 0.0056f, 0.0060f, 0.0065f, 0.0070f, 0.0075f, 0.0080f, 0.0086f, 
-0.0091f, 0.0097f, 0.0103f, 0.0109f, 0.0115f, 0.0121f, 0.0127f, 0.0133f, 
-0.0138f, 0.0144f, 0.0150f, 0.0155f, 0.0161f, 0.0166f, 0.0170f, 0.0175f, 
-0.0179f, 0.0183f, 0.0186f, 0.0189f, 0.0192f, 0.0194f, 0.0196f, 0.0197f, 
-0.0198f, 0.0198f
-};
-static const float ggauss57[37] = {
-0.0047f, 0.0051f, 0.0055f, 0.0058f, 0.0063f, 0.0067f, 0.0071f, 0.0076f, 
-0.0080f, 0.0085f, 0.0090f, 0.0095f, 0.0100f, 0.0105f, 0.0110f, 0.0115f, 
-0.0120f, 0.0125f, 0.0130f, 0.0134f, 0.0139f, 0.0144f, 0.0148f, 0.0152f, 
-0.0156f, 0.0160f, 0.0164f, 0.0167f, 0.0170f, 0.0173f, 0.0175f, 0.0177f, 
-0.0179f, 0.0180f, 0.0181f, 0.0181f, 0.0182f
-};
-static const float ggauss58[41] = {
-0.0041f, 0.0044f, 0.0047f, 0.0050f, 0.0054f, 0.0057f, 0.0060f, 0.0064f, 
-0.0068f, 0.0072f, 0.0076f, 0.0080f, 0.0084f, 0.0088f, 0.0092f, 0.0096f, 
-0.0101f, 0.0105f, 0.0109f, 0.0113f, 0.0117f, 0.0121f, 0.0125f, 0.0129f, 
-0.0133f, 0.0137f, 0.0140f, 0.0144f, 0.0147f, 0.0150f, 0.0153f, 0.0155f, 
-0.0158f, 0.0160f, 0.0162f, 0.0163f, 0.0164f, 0.0165f, 0.0166f, 0.0167f, 
-0.0167f
-};
-static const float ggauss59[44] = {
-0.0039f, 0.0042f, 0.0044f, 0.0047f, 0.0050f, 0.0053f, 0.0056f, 0.0059f, 
-0.0062f, 0.0065f, 0.0068f, 0.0072f, 0.0075f, 0.0079f, 0.0082f, 0.0086f, 
-0.0089f, 0.0093f, 0.0096f, 0.0100f, 0.0104f, 0.0107f, 0.0110f, 0.0114f, 
-0.0117f, 0.0120f, 0.0124f, 0.0127f, 0.0130f, 0.0132f, 0.0135f, 0.0138f, 
-0.0140f, 0.0142f, 0.0144f, 0.0146f, 0.0148f, 0.0149f, 0.0150f, 0.0151f, 
-0.0152f, 0.0153f, 0.0153f, 0.0153f
-};
-static const float ggauss60[48] = {
-0.0036f, 0.0038f, 0.0040f, 0.0042f, 0.0044f, 0.0047f, 0.0049f, 0.0052f, 
-0.0055f, 0.0057f, 0.0060f, 0.0063f, 0.0066f, 0.0068f, 0.0071f, 0.0074f, 
-0.0077f, 0.0080f, 0.0083f, 0.0086f, 0.0089f, 0.0092f, 0.0095f, 0.0098f, 
-0.0101f, 0.0104f, 0.0107f, 0.0109f, 0.0112f, 0.0115f, 0.0117f, 0.0120f, 
-0.0122f, 0.0124f, 0.0126f, 0.0128f, 0.0130f, 0.0132f, 0.0134f, 0.0135f, 
-0.0136f, 0.0137f, 0.0138f, 0.0139f, 0.0140f, 0.0140f, 0.0140f, 0.0140f
-};
-static const float ggauss61[52] = {
-0.0033f, 0.0035f, 0.0037f, 0.0039f, 0.0041f, 0.0043f, 0.0045f, 0.0047f, 
-0.0049f, 0.0051f, 0.0053f, 0.0056f, 0.0058f, 0.0060f, 0.0063f, 0.0065f, 
-0.0068f, 0.0070f, 0.0073f, 0.0075f, 0.0078f, 0.0080f, 0.0083f, 0.0085f, 
-0.0088f, 0.0090f, 0.0093f, 0.0095f, 0.0098f, 0.0100f, 0.0102f, 0.0105f, 
-0.0107f, 0.0109f, 0.0111f, 0.0113f, 0.0115f, 0.0116f, 0.0118f, 0.0120f, 
-0.0121f, 0.0122f, 0.0124f, 0.0125f, 0.0126f, 0.0126f, 0.0127f, 0.0128f, 
-0.0128f, 0.0129f, 0.0129f, 0.0129f
-};
-static const float ggauss62[57] = {
-0.0030f, 0.0031f, 0.0033f, 0.0034f, 0.0036f, 0.0038f, 0.0039f, 0.0041f, 
-0.0043f, 0.0045f, 0.0047f, 0.0048f, 0.0050f, 0.0052f, 0.0054f, 0.0056f, 
-0.0058f, 0.0060f, 0.0063f, 0.0065f, 0.0067f, 0.0069f, 0.0071f, 0.0073f, 
-0.0075f, 0.0077f, 0.0080f, 0.0082f, 0.0084f, 0.0086f, 0.0088f, 0.0090f, 
-0.0092f, 0.0094f, 0.0096f, 0.0097f, 0.0099f, 0.0101f, 0.0103f, 0.0104f, 
-0.0106f, 0.0107f, 0.0108f, 0.0110f, 0.0111f, 0.0112f, 0.0113f, 0.0114f, 
-0.0115f, 0.0116f, 0.0116f, 0.0117f, 0.0117f, 0.0118f, 0.0118f, 0.0118f, 
-0.0118f
-};
-static const float ggauss63[62] = {
-0.0027f, 0.0029f, 0.0030f, 0.0031f, 0.0032f, 0.0034f, 0.0035f, 0.0037f, 
-0.0038f, 0.0040f, 0.0041f, 0.0043f, 0.0045f, 0.0046f, 0.0048f, 0.0049f, 
-0.0051f, 0.0053f, 0.0055f, 0.0056f, 0.0058f, 0.0060f, 0.0062f, 0.0063f, 
-0.0065f, 0.0067f, 0.0069f, 0.0071f, 0.0072f, 0.0074f, 0.0076f, 0.0078f, 
-0.0079f, 0.0081f, 0.0083f, 0.0084f, 0.0086f, 0.0088f, 0.0089f, 0.0091f, 
-0.0092f, 0.0094f, 0.0095f, 0.0096f, 0.0098f, 0.0099f, 0.0100f, 0.0101f, 
-0.0102f, 0.0103f, 0.0104f, 0.0105f, 0.0105f, 0.0106f, 0.0107f, 0.0107f, 
-0.0108f, 0.0108f, 0.0108f, 0.0108f, 0.0109f, 0.0109f
-};
-static const float ggauss64[65] = {
-0.0028f, 0.0029f, 0.0030f, 0.0031f, 0.0032f, 0.0034f, 0.0035f, 0.0036f, 
-0.0037f, 0.0039f, 0.0040f, 0.0041f, 0.0043f, 0.0044f, 0.0046f, 0.0047f, 
-0.0048f, 0.0050f, 0.0051f, 0.0053f, 0.0054f, 0.0056f, 0.0057f, 0.0059f, 
-0.0060f, 0.0062f, 0.0063f, 0.0065f, 0.0066f, 0.0068f, 0.0069f, 0.0071f, 
-0.0072f, 0.0074f, 0.0075f, 0.0077f, 0.0078f, 0.0079f, 0.0081f, 0.0082f, 
-0.0083f, 0.0084f, 0.0086f, 0.0087f, 0.0088f, 0.0089f, 0.0090f, 0.0091f, 
-0.0092f, 0.0093f, 0.0094f, 0.0094f, 0.0095f, 0.0096f, 0.0097f, 0.0097f, 
-0.0098f, 0.0098f, 0.0099f, 0.0099f, 0.0099f, 0.0099f, 0.0100f, 0.0100f, 
-0.0100f
-};
-static const float *gptr_tab_gauss[64] = {
-ggauss1, ggauss2, ggauss3, ggauss4, 
-ggauss5, ggauss6, ggauss7, ggauss8, 
-ggauss9, ggauss10, ggauss11, ggauss12, 
-ggauss13, ggauss14, ggauss15, ggauss16, 
-ggauss17, ggauss18, ggauss19, ggauss20, 
-ggauss21, ggauss22, ggauss23, ggauss24, 
-ggauss25, ggauss26, ggauss27, ggauss28, 
-ggauss29, ggauss30, ggauss31, ggauss32, 
-ggauss33, ggauss34, ggauss35, ggauss36, 
-ggauss37, ggauss38, ggauss39, ggauss40, 
-ggauss41, ggauss42, ggauss43, ggauss44, 
-ggauss45, ggauss46, ggauss47, ggauss48, 
-ggauss49, ggauss50, ggauss51, ggauss52, 
-ggauss53, ggauss54, ggauss55, ggauss56, 
-ggauss57, ggauss58, ggauss59, ggauss60, 
-ggauss61, ggauss62, ggauss63, ggauss64
-};
diff --git a/lib/qra/qra64/fadenlorentz.c b/lib/qra/qra64/fadenlorentz.c
deleted file mode 100644
index 673a89033..000000000
--- a/lib/qra/qra64/fadenlorentz.c
+++ /dev/null
@@ -1,304 +0,0 @@
-// Lorentz energy fading tables for QRA64
-static const int glen_tab_lorentz[64] = {
-  2,   2,   2,   2,   2,   2,   2,   2, 
-  2,   2,   2,   2,   2,   2,   3,   3, 
-  3,   3,   3,   3,   3,   4,   4,   4, 
-  4,   4,   5,   5,   5,   5,   6,   6, 
-  7,   7,   7,   8,   8,   9,  10,  10, 
- 11,  12,  13,  14,  15,  16,  17,  19, 
- 20,  22,  23,  25,  27,  30,  32,  35, 
- 38,  41,  45,  49,  53,  57,  62,  65
-};
-static const float glorentz1[2] = {
-0.0214f, 0.9107f
-};
-static const float glorentz2[2] = {
-0.0244f, 0.9030f
-};
-static const float glorentz3[2] = {
-0.0280f, 0.8950f
-};
-static const float glorentz4[2] = {
-0.0314f, 0.8865f
-};
-static const float glorentz5[2] = {
-0.0349f, 0.8773f
-};
-static const float glorentz6[2] = {
-0.0388f, 0.8675f
-};
-static const float glorentz7[2] = {
-0.0426f, 0.8571f
-};
-static const float glorentz8[2] = {
-0.0463f, 0.8459f
-};
-static const float glorentz9[2] = {
-0.0500f, 0.8339f
-};
-static const float glorentz10[2] = {
-0.0538f, 0.8210f
-};
-static const float glorentz11[2] = {
-0.0579f, 0.8074f
-};
-static const float glorentz12[2] = {
-0.0622f, 0.7930f
-};
-static const float glorentz13[2] = {
-0.0668f, 0.7777f
-};
-static const float glorentz14[2] = {
-0.0715f, 0.7616f
-};
-static const float glorentz15[3] = {
-0.0196f, 0.0765f, 0.7445f
-};
-static const float glorentz16[3] = {
-0.0210f, 0.0816f, 0.7267f
-};
-static const float glorentz17[3] = {
-0.0226f, 0.0870f, 0.7080f
-};
-static const float glorentz18[3] = {
-0.0242f, 0.0925f, 0.6885f
-};
-static const float glorentz19[3] = {
-0.0259f, 0.0981f, 0.6682f
-};
-static const float glorentz20[3] = {
-0.0277f, 0.1039f, 0.6472f
-};
-static const float glorentz21[3] = {
-0.0296f, 0.1097f, 0.6255f
-};
-static const float glorentz22[4] = {
-0.0143f, 0.0316f, 0.1155f, 0.6031f
-};
-static const float glorentz23[4] = {
-0.0153f, 0.0337f, 0.1213f, 0.5803f
-};
-static const float glorentz24[4] = {
-0.0163f, 0.0358f, 0.1270f, 0.5570f
-};
-static const float glorentz25[4] = {
-0.0174f, 0.0381f, 0.1325f, 0.5333f
-};
-static const float glorentz26[4] = {
-0.0186f, 0.0405f, 0.1378f, 0.5095f
-};
-static const float glorentz27[5] = {
-0.0113f, 0.0198f, 0.0429f, 0.1428f, 0.4855f
-};
-static const float glorentz28[5] = {
-0.0120f, 0.0211f, 0.0455f, 0.1473f, 0.4615f
-};
-static const float glorentz29[5] = {
-0.0129f, 0.0225f, 0.0481f, 0.1514f, 0.4376f
-};
-static const float glorentz30[5] = {
-0.0137f, 0.0239f, 0.0508f, 0.1549f, 0.4140f
-};
-static const float glorentz31[6] = {
-0.0095f, 0.0147f, 0.0254f, 0.0536f, 0.1578f, 0.3907f
-};
-static const float glorentz32[6] = {
-0.0101f, 0.0156f, 0.0270f, 0.0564f, 0.1600f, 0.3680f
-};
-static const float glorentz33[7] = {
-0.0076f, 0.0109f, 0.0167f, 0.0287f, 0.0592f, 0.1614f, 0.3458f
-};
-static const float glorentz34[7] = {
-0.0081f, 0.0116f, 0.0178f, 0.0305f, 0.0621f, 0.1620f, 0.3243f
-};
-static const float glorentz35[7] = {
-0.0087f, 0.0124f, 0.0190f, 0.0324f, 0.0649f, 0.1618f, 0.3035f
-};
-static const float glorentz36[8] = {
-0.0069f, 0.0093f, 0.0133f, 0.0203f, 0.0343f, 0.0676f, 0.1607f, 0.2836f
-};
-static const float glorentz37[8] = {
-0.0074f, 0.0100f, 0.0142f, 0.0216f, 0.0362f, 0.0702f, 0.1588f, 0.2645f
-};
-static const float glorentz38[9] = {
-0.0061f, 0.0080f, 0.0107f, 0.0152f, 0.0230f, 0.0382f, 0.0726f, 0.1561f, 
-0.2464f
-};
-static const float glorentz39[10] = {
-0.0052f, 0.0066f, 0.0086f, 0.0115f, 0.0162f, 0.0244f, 0.0402f, 0.0747f, 
-0.1526f, 0.2291f
-};
-static const float glorentz40[10] = {
-0.0056f, 0.0071f, 0.0092f, 0.0123f, 0.0173f, 0.0259f, 0.0422f, 0.0766f, 
-0.1484f, 0.2128f
-};
-static const float glorentz41[11] = {
-0.0049f, 0.0061f, 0.0076f, 0.0098f, 0.0132f, 0.0184f, 0.0274f, 0.0441f, 
-0.0780f, 0.1437f, 0.1975f
-};
-static const float glorentz42[12] = {
-0.0044f, 0.0053f, 0.0065f, 0.0082f, 0.0106f, 0.0141f, 0.0196f, 0.0290f, 
-0.0460f, 0.0791f, 0.1384f, 0.1831f
-};
-static const float glorentz43[13] = {
-0.0040f, 0.0048f, 0.0057f, 0.0070f, 0.0088f, 0.0113f, 0.0150f, 0.0209f, 
-0.0305f, 0.0477f, 0.0797f, 0.1327f, 0.1695f
-};
-static const float glorentz44[14] = {
-0.0037f, 0.0043f, 0.0051f, 0.0062f, 0.0075f, 0.0094f, 0.0121f, 0.0160f, 
-0.0221f, 0.0321f, 0.0493f, 0.0799f, 0.1267f, 0.1568f
-};
-static const float glorentz45[15] = {
-0.0035f, 0.0040f, 0.0047f, 0.0055f, 0.0066f, 0.0081f, 0.0101f, 0.0129f, 
-0.0171f, 0.0234f, 0.0335f, 0.0506f, 0.0795f, 0.1204f, 0.1450f
-};
-static const float glorentz46[16] = {
-0.0033f, 0.0037f, 0.0043f, 0.0050f, 0.0059f, 0.0071f, 0.0087f, 0.0108f, 
-0.0138f, 0.0181f, 0.0246f, 0.0349f, 0.0517f, 0.0786f, 0.1141f, 0.1340f
-};
-static const float glorentz47[17] = {
-0.0031f, 0.0035f, 0.0040f, 0.0046f, 0.0054f, 0.0064f, 0.0077f, 0.0093f, 
-0.0116f, 0.0147f, 0.0192f, 0.0259f, 0.0362f, 0.0525f, 0.0773f, 0.1076f, 
-0.1237f
-};
-static const float glorentz48[19] = {
-0.0027f, 0.0030f, 0.0034f, 0.0038f, 0.0043f, 0.0050f, 0.0058f, 0.0069f, 
-0.0082f, 0.0100f, 0.0123f, 0.0156f, 0.0203f, 0.0271f, 0.0374f, 0.0530f, 
-0.0755f, 0.1013f, 0.1141f
-};
-static const float glorentz49[20] = {
-0.0026f, 0.0029f, 0.0032f, 0.0036f, 0.0041f, 0.0047f, 0.0054f, 0.0063f, 
-0.0074f, 0.0088f, 0.0107f, 0.0131f, 0.0165f, 0.0213f, 0.0282f, 0.0383f, 
-0.0531f, 0.0734f, 0.0950f, 0.1053f
-};
-static const float glorentz50[22] = {
-0.0023f, 0.0025f, 0.0028f, 0.0031f, 0.0035f, 0.0039f, 0.0044f, 0.0050f, 
-0.0058f, 0.0067f, 0.0079f, 0.0094f, 0.0114f, 0.0139f, 0.0175f, 0.0223f, 
-0.0292f, 0.0391f, 0.0529f, 0.0709f, 0.0889f, 0.0971f
-};
-static const float glorentz51[23] = {
-0.0023f, 0.0025f, 0.0027f, 0.0030f, 0.0034f, 0.0037f, 0.0042f, 0.0048f, 
-0.0054f, 0.0062f, 0.0072f, 0.0085f, 0.0100f, 0.0121f, 0.0148f, 0.0184f, 
-0.0233f, 0.0301f, 0.0396f, 0.0524f, 0.0681f, 0.0829f, 0.0894f
-};
-static const float glorentz52[25] = {
-0.0021f, 0.0023f, 0.0025f, 0.0027f, 0.0030f, 0.0033f, 0.0036f, 0.0040f, 
-0.0045f, 0.0051f, 0.0058f, 0.0067f, 0.0077f, 0.0090f, 0.0107f, 0.0128f, 
-0.0156f, 0.0192f, 0.0242f, 0.0308f, 0.0398f, 0.0515f, 0.0650f, 0.0772f, 
-0.0824f
-};
-static const float glorentz53[27] = {
-0.0019f, 0.0021f, 0.0022f, 0.0024f, 0.0027f, 0.0029f, 0.0032f, 0.0035f, 
-0.0039f, 0.0044f, 0.0049f, 0.0055f, 0.0062f, 0.0072f, 0.0083f, 0.0096f, 
-0.0113f, 0.0135f, 0.0164f, 0.0201f, 0.0249f, 0.0314f, 0.0398f, 0.0502f, 
-0.0619f, 0.0718f, 0.0759f
-};
-static const float glorentz54[30] = {
-0.0017f, 0.0018f, 0.0019f, 0.0021f, 0.0022f, 0.0024f, 0.0026f, 0.0029f, 
-0.0031f, 0.0034f, 0.0038f, 0.0042f, 0.0047f, 0.0052f, 0.0059f, 0.0067f, 
-0.0076f, 0.0088f, 0.0102f, 0.0120f, 0.0143f, 0.0171f, 0.0208f, 0.0256f, 
-0.0317f, 0.0395f, 0.0488f, 0.0586f, 0.0666f, 0.0698f
-};
-static const float glorentz55[32] = {
-0.0016f, 0.0017f, 0.0018f, 0.0019f, 0.0021f, 0.0022f, 0.0024f, 0.0026f, 
-0.0028f, 0.0031f, 0.0034f, 0.0037f, 0.0041f, 0.0045f, 0.0050f, 0.0056f, 
-0.0063f, 0.0071f, 0.0081f, 0.0094f, 0.0108f, 0.0127f, 0.0149f, 0.0178f, 
-0.0214f, 0.0261f, 0.0318f, 0.0389f, 0.0470f, 0.0553f, 0.0618f, 0.0643f
-};
-static const float glorentz56[35] = {
-0.0014f, 0.0015f, 0.0016f, 0.0017f, 0.0018f, 0.0020f, 0.0021f, 0.0023f, 
-0.0024f, 0.0026f, 0.0028f, 0.0031f, 0.0033f, 0.0036f, 0.0040f, 0.0044f, 
-0.0049f, 0.0054f, 0.0060f, 0.0067f, 0.0076f, 0.0087f, 0.0099f, 0.0114f, 
-0.0133f, 0.0156f, 0.0184f, 0.0220f, 0.0264f, 0.0318f, 0.0381f, 0.0451f, 
-0.0520f, 0.0572f, 0.0591f
-};
-static const float glorentz57[38] = {
-0.0013f, 0.0014f, 0.0015f, 0.0016f, 0.0017f, 0.0018f, 0.0019f, 0.0020f, 
-0.0021f, 0.0023f, 0.0024f, 0.0026f, 0.0028f, 0.0031f, 0.0033f, 0.0036f, 
-0.0039f, 0.0043f, 0.0047f, 0.0052f, 0.0058f, 0.0064f, 0.0072f, 0.0081f, 
-0.0092f, 0.0104f, 0.0120f, 0.0139f, 0.0162f, 0.0190f, 0.0224f, 0.0265f, 
-0.0315f, 0.0371f, 0.0431f, 0.0487f, 0.0529f, 0.0544f
-};
-static const float glorentz58[41] = {
-0.0012f, 0.0013f, 0.0014f, 0.0014f, 0.0015f, 0.0016f, 0.0017f, 0.0018f, 
-0.0019f, 0.0020f, 0.0022f, 0.0023f, 0.0025f, 0.0026f, 0.0028f, 0.0030f, 
-0.0033f, 0.0036f, 0.0039f, 0.0042f, 0.0046f, 0.0050f, 0.0056f, 0.0061f, 
-0.0068f, 0.0076f, 0.0086f, 0.0097f, 0.0110f, 0.0125f, 0.0144f, 0.0167f, 
-0.0194f, 0.0226f, 0.0265f, 0.0309f, 0.0359f, 0.0409f, 0.0455f, 0.0488f, 
-0.0500f
-};
-static const float glorentz59[45] = {
-0.0011f, 0.0012f, 0.0012f, 0.0013f, 0.0013f, 0.0014f, 0.0015f, 0.0016f, 
-0.0016f, 0.0017f, 0.0018f, 0.0019f, 0.0021f, 0.0022f, 0.0023f, 0.0025f, 
-0.0026f, 0.0028f, 0.0030f, 0.0033f, 0.0035f, 0.0038f, 0.0041f, 0.0045f, 
-0.0049f, 0.0054f, 0.0059f, 0.0065f, 0.0072f, 0.0081f, 0.0090f, 0.0102f, 
-0.0115f, 0.0130f, 0.0149f, 0.0171f, 0.0197f, 0.0227f, 0.0263f, 0.0302f, 
-0.0345f, 0.0387f, 0.0425f, 0.0451f, 0.0460f
-};
-static const float glorentz60[49] = {
-0.0010f, 0.0011f, 0.0011f, 0.0012f, 0.0012f, 0.0013f, 0.0013f, 0.0014f, 
-0.0014f, 0.0015f, 0.0016f, 0.0017f, 0.0018f, 0.0019f, 0.0020f, 0.0021f, 
-0.0022f, 0.0024f, 0.0025f, 0.0027f, 0.0028f, 0.0030f, 0.0033f, 0.0035f, 
-0.0038f, 0.0041f, 0.0044f, 0.0048f, 0.0052f, 0.0057f, 0.0063f, 0.0069f, 
-0.0077f, 0.0085f, 0.0095f, 0.0106f, 0.0119f, 0.0135f, 0.0153f, 0.0174f, 
-0.0199f, 0.0227f, 0.0259f, 0.0293f, 0.0330f, 0.0365f, 0.0395f, 0.0415f, 
-0.0423f
-};
-static const float glorentz61[53] = {
-0.0009f, 0.0010f, 0.0010f, 0.0011f, 0.0011f, 0.0011f, 0.0012f, 0.0012f, 
-0.0013f, 0.0014f, 0.0014f, 0.0015f, 0.0016f, 0.0016f, 0.0017f, 0.0018f, 
-0.0019f, 0.0020f, 0.0021f, 0.0023f, 0.0024f, 0.0025f, 0.0027f, 0.0029f, 
-0.0031f, 0.0033f, 0.0035f, 0.0038f, 0.0041f, 0.0044f, 0.0047f, 0.0051f, 
-0.0056f, 0.0061f, 0.0067f, 0.0073f, 0.0081f, 0.0089f, 0.0099f, 0.0110f, 
-0.0124f, 0.0139f, 0.0156f, 0.0176f, 0.0199f, 0.0225f, 0.0253f, 0.0283f, 
-0.0314f, 0.0343f, 0.0367f, 0.0383f, 0.0389f
-};
-static const float glorentz62[57] = {
-0.0009f, 0.0009f, 0.0009f, 0.0010f, 0.0010f, 0.0011f, 0.0011f, 0.0011f, 
-0.0012f, 0.0012f, 0.0013f, 0.0013f, 0.0014f, 0.0015f, 0.0015f, 0.0016f, 
-0.0017f, 0.0018f, 0.0019f, 0.0020f, 0.0021f, 0.0022f, 0.0023f, 0.0024f, 
-0.0026f, 0.0027f, 0.0029f, 0.0031f, 0.0033f, 0.0035f, 0.0038f, 0.0040f, 
-0.0043f, 0.0047f, 0.0050f, 0.0055f, 0.0059f, 0.0064f, 0.0070f, 0.0077f, 
-0.0085f, 0.0093f, 0.0103f, 0.0114f, 0.0127f, 0.0142f, 0.0158f, 0.0177f, 
-0.0198f, 0.0221f, 0.0246f, 0.0272f, 0.0297f, 0.0321f, 0.0340f, 0.0353f, 
-0.0357f
-};
-static const float glorentz63[62] = {
-0.0008f, 0.0008f, 0.0009f, 0.0009f, 0.0009f, 0.0010f, 0.0010f, 0.0010f, 
-0.0011f, 0.0011f, 0.0011f, 0.0012f, 0.0012f, 0.0013f, 0.0013f, 0.0014f, 
-0.0015f, 0.0015f, 0.0016f, 0.0017f, 0.0017f, 0.0018f, 0.0019f, 0.0020f, 
-0.0021f, 0.0022f, 0.0023f, 0.0025f, 0.0026f, 0.0028f, 0.0029f, 0.0031f, 
-0.0033f, 0.0035f, 0.0038f, 0.0040f, 0.0043f, 0.0046f, 0.0050f, 0.0053f, 
-0.0058f, 0.0062f, 0.0068f, 0.0074f, 0.0081f, 0.0088f, 0.0097f, 0.0106f, 
-0.0117f, 0.0130f, 0.0144f, 0.0159f, 0.0176f, 0.0195f, 0.0216f, 0.0237f, 
-0.0259f, 0.0280f, 0.0299f, 0.0315f, 0.0325f, 0.0328f
-};
-static const float glorentz64[65] = {
-0.0008f, 0.0008f, 0.0008f, 0.0009f, 0.0009f, 0.0009f, 0.0010f, 0.0010f, 
-0.0010f, 0.0011f, 0.0011f, 0.0012f, 0.0012f, 0.0012f, 0.0013f, 0.0013f, 
-0.0014f, 0.0014f, 0.0015f, 0.0016f, 0.0016f, 0.0017f, 0.0018f, 0.0019f, 
-0.0020f, 0.0021f, 0.0022f, 0.0023f, 0.0024f, 0.0025f, 0.0027f, 0.0028f, 
-0.0030f, 0.0031f, 0.0033f, 0.0035f, 0.0038f, 0.0040f, 0.0043f, 0.0046f, 
-0.0049f, 0.0052f, 0.0056f, 0.0061f, 0.0066f, 0.0071f, 0.0077f, 0.0084f, 
-0.0091f, 0.0100f, 0.0109f, 0.0120f, 0.0132f, 0.0145f, 0.0159f, 0.0175f, 
-0.0192f, 0.0209f, 0.0228f, 0.0246f, 0.0264f, 0.0279f, 0.0291f, 0.0299f, 
-0.0301f
-};
-static const float *gptr_tab_lorentz[64] = {
-glorentz1, glorentz2, glorentz3, glorentz4, 
-glorentz5, glorentz6, glorentz7, glorentz8, 
-glorentz9, glorentz10, glorentz11, glorentz12, 
-glorentz13, glorentz14, glorentz15, glorentz16, 
-glorentz17, glorentz18, glorentz19, glorentz20, 
-glorentz21, glorentz22, glorentz23, glorentz24, 
-glorentz25, glorentz26, glorentz27, glorentz28, 
-glorentz29, glorentz30, glorentz31, glorentz32, 
-glorentz33, glorentz34, glorentz35, glorentz36, 
-glorentz37, glorentz38, glorentz39, glorentz40, 
-glorentz41, glorentz42, glorentz43, glorentz44, 
-glorentz45, glorentz46, glorentz47, glorentz48, 
-glorentz49, glorentz50, glorentz51, glorentz52, 
-glorentz53, glorentz54, glorentz55, glorentz56, 
-glorentz57, glorentz58, glorentz59, glorentz60, 
-glorentz61, glorentz62, glorentz63, glorentz64
-};
diff --git a/lib/qra/qra64/main.c b/lib/qra/qra64/main.c
deleted file mode 100644
index b685fd316..000000000
--- a/lib/qra/qra64/main.c
+++ /dev/null
@@ -1,746 +0,0 @@
-/*
-main.c 
-QRA64 mode encode/decode tests
-
-(c) 2016 - Nico Palermo, IV3NWV
-
-Thanks to Andrea Montefusco IW0HDV for his help on adapting the sources
-to OSs other than MS Windows
-
-------------------------------------------------------------------------------
-This file is part of the qracodes project, a Forward Error Control
-encoding/decoding package based on Q-ary RA (Repeat and Accumulate) LDPC codes.
-
-Files in this package:
-   main.c		 - this file
-   qra64.c/.h     - qra64 mode encode/decoding functions
-
-   ../qracodes/normrnd.{c,h}   - random gaussian number generator
-   ../qracodes/npfwht.{c,h}    - Fast Walsh-Hadamard Transforms
-   ../qracodes/pdmath.{c,h}    - Elementary math on probability distributions
-   ../qracodes/qra12_63_64_irr_b.{c,h} - Tables for a QRA(12,63) irregular RA 
-                                         code over GF(64)
-   ../qracodes/qra13_64_64_irr_e.{c,h} - Tables for a QRA(13,64) irregular RA 
-                                         code over GF(64)
-   ../qracodes/qracodes.{c,h}  - QRA codes encoding/decoding functions
-
--------------------------------------------------------------------------------
-
-   qracodes 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.
-   qracodes 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 qracodes source distribution.  
-   If not, see <http://www.gnu.org/licenses/>.
-
------------------------------------------------------------------------------
-
-The code used by the QRA64 mode is the code: QRA13_64_64_IRR_E: K=13
-N=64 Q=64 irregular QRA code (defined in qra13_64_64_irr_e.{h,c}).
-
-This code has been designed to include a CRC as the 13th information
-symbol and improve the code UER (Undetected Error Rate).  The CRC
-symbol is not sent along the channel (the codes are punctured) and the
-resulting code is still a (12,63) code with an effective code rate of
-R = 12/63.
-*/
-
-// OS dependent defines and includes ------------------------------------------
-
-#if _WIN32 // note the underscore: without it, it's not msdn official!
-// Windows (x64 and x86)
-#include <windows.h>   // required only for GetTickCount(...)
-#include <process.h>   // _beginthread
-#endif
-
-#if __linux__
-#include <unistd.h>
-#include <time.h>
-
-unsigned GetTickCount(void) {
-    struct timespec ts;
-    unsigned theTick = 0U;
-    clock_gettime( CLOCK_REALTIME, &ts );
-    theTick  = ts.tv_nsec / 1000000;
-    theTick += ts.tv_sec * 1000;
-    return theTick;
-}
-#endif
-
-#if __APPLE__
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "qra64.h"
-#include "../qracodes/normrnd.h"		   // gaussian numbers generator
-
-// ----------------------------------------------------------------------------
-
-// channel types
-#define CHANNEL_AWGN     0
-#define CHANNEL_RAYLEIGH 1
-#define CHANNEL_FASTFADE 2
-
-#define JT65_SNR_EBNO_OFFSET 29.1f		// with the synch used in JT65
-#define QRA64_SNR_EBNO_OFFSET 31.0f		// with the costas array synch 
-
-void printwordd(char *msg, int *x, int size)
-{
-  int k;
-  printf("\n%s ",msg);
-  for (k=0;k<size;k++)
-    printf("%2d ",x[k]);
-  printf("\n");
-}
-void printwordh(char *msg, int *x, int size)
-{
-  int k;
-  printf("\n%s ",msg);
-  for (k=0;k<size;k++)
-    printf("%02hx ",x[k]);
-  printf("\n");
-}
-
-#define NSAMPLES (QRA64_N*QRA64_M)
-
-static float rp[NSAMPLES];
-static float rq[NSAMPLES];
-static float chp[NSAMPLES];
-static float chq[NSAMPLES];
-static float r[NSAMPLES];
-
-float *mfskchannel(int *x, int channel_type, float EbNodB)
-{
-/*
-Simulate an MFSK channel, either AWGN or Rayleigh.
-
-x is a pointer to the transmitted codeword, an array of QRA64_N
-integers in the range 0..63.
-
-Returns the received symbol energies (squared amplitudes) as an array of 
-(QRA64_M*QRA64_N) floats.  The first QRA64_M entries of this array are 
-the energies of the first symbol in the codeword.  The second QRA64_M 
-entries are those of the second symbol, and so on up to the last codeword 
-symbol.
-*/
-  const float No = 1.0f;		        // noise spectral density
-  const float sigma   = (float)sqrt(No/2.0f);	// std dev of noise I/Q components
-  const float sigmach = (float)sqrt(1/2.0f);	// std dev of channel I/Q gains
-  const float R = 1.0f*QRA64_K/QRA64_N;	
-
-  float EbNo = (float)pow(10,EbNodB/10);
-  float EsNo = 1.0f*QRA64_m*R*EbNo;
-  float Es = EsNo*No;
-  float A = (float)sqrt(Es);
-  int k;
-
-  normrnd_s(rp,NSAMPLES,0,sigma);
-  normrnd_s(rq,NSAMPLES,0,sigma);
-
-  if(EbNodB>-15) 
-	if (channel_type == CHANNEL_AWGN) 
-	    for (k=0;k<QRA64_N;k++) 
-		  rp[k*QRA64_M+x[k]]+=A;
-	else 
-		if (channel_type == CHANNEL_RAYLEIGH) {
-			normrnd_s(chp,QRA64_N,0,sigmach);
-			normrnd_s(chq,QRA64_N,0,sigmach);
-			for (k=0;k<QRA64_N;k++) {
-				rp[k*QRA64_M+x[k]]+=A*chp[k];
-				rq[k*QRA64_M+x[k]]+=A*chq[k];
-				}
-			}
-		else {
-		return 0;	// unknown channel type
-		}
-
-  // compute the squares of the amplitudes of the received samples
-  for (k=0;k<NSAMPLES;k++) 
-    r[k] = rp[k]*rp[k] + rq[k]*rq[k];
-
-  return r;
-}
-
-// These defines are some packed fields as computed by JT65 
-#define CALL_IV3NWV		0x7F85AE7	
-#define CALL_K1JT		0xF70DDD7
-#define GRID_JN66		0x3AE4		// JN66
-#define GRID_73 		0x7ED0		// 73
-
-char decode_type[12][32] = {
-  "[?    ?    ?] AP0",
-  "[CQ   ?    ?] AP27",
-  "[CQ   ?     ] AP42",
-  "[CALL ?    ?] AP29",
-  "[CALL ?     ] AP44",
-  "[CALL CALL ?] AP57",
-  "[?    CALL ?] AP29",
-  "[?    CALL  ] AP44",
-  "[CALL CALL G] AP72",
-  "[CQ   CALL ?] AP55",
-  "[CQ   CALL  ] AP70",
-  "[CQ   CALL G] AP70"
-};
-char apmode_type[3][32] = {
-  "NO AP",
-  "AUTO AP",
-  "USER AP"
-};
-
-int test_proc_1(int channel_type, float EbNodB, int mode)
-{
-/*
-Here we simulate the following (dummy) QSO:
-
-1) CQ IV3NWV
-2)                 IV3NWV K1JT
-3) K1JT IV3NWV 73
-4)                 IV3NWV K1JT 73
-
-No message repetition is attempted
-
-The QSO is counted as successfull if IV3NWV received the last message
-When mode=QRA_AUTOAP each decoder attempts to decode the message sent
-by the other station using the a-priori information derived by what
-has been already decoded in a previous phase of the QSO if decoding
-with no a-priori information has not been successful.
-
-Step 1) K1JT's decoder first attempts to decode msgs of type [? ? ?]
-and if this attempt fails, it attempts to decode [CQ/QRZ ? ?]  or
-[CQ/QRZ ?] msgs
-
-Step 2) if IV3NWV's decoder is unable to decode K1JT's without AP it
-attempts to decode messages of the type [IV3NWV ? ?] and [IV3NWV ?].
-
-Step 3) K1JT's decoder attempts to decode [? ? ?] and [K1JT IV3NWV ?]
-(this last decode type has been enabled by K1JT's encoder at step 2)
-
-Step 4) IV3NWV's decoder attempts to decode [? ? ?] and [IV3NWV K1JT
-?] (this last decode type has been enabled by IV3NWV's encoder at step
-3)
-
-At each step the simulation reports if a decode was successful.  In
-this case it also reports the type of decode (see table decode_type
-above)
-
-When mode=QRA_NOAP, only [? ? ?] decodes are attempted and no a-priori
-information is used by the decoder
-
-The function returns 0 if all of the four messages have been decoded
-by their recipients (with no retries) and -1 if any of them could not
-be decoded
-*/
-
-  int x[QRA64_K], xdec[QRA64_K];
-  int y[QRA64_N];
-  float *rx;
-  int rc;
-
-// Each simulated station must use its own codec since it might work with
-// different a-priori information.
-  qra64codec *codec_iv3nwv = qra64_init(mode);  // codec for IV3NWV
-  qra64codec *codec_k1jt   = qra64_init(mode);    // codec for K1JT
-
-// Step 1a: IV3NWV makes a CQ call (with no grid)
-  printf("IV3NWV tx: CQ IV3NWV\n");
-  encodemsg_jt65(x,CALL_CQ,CALL_IV3NWV,GRID_BLANK);
-  qra64_encode(codec_iv3nwv, y, x);
-  rx = mfskchannel(y,channel_type,EbNodB);
-
-// Step 1b: K1JT attempts to decode [? ? ?], [CQ/QRZ ? ?] or [CQ/QRZ ?]
-  rc = qra64_decode(codec_k1jt, 0, xdec,rx);
-  if (rc>=0) { // decoded
-    printf("K1JT   rx: received with apcode=%d %s\n",rc, decode_type[rc]);
-
-// Step 2a: K1JT replies to IV3NWV (with no grid)
-    printf("K1JT   tx: IV3NWV K1JT\n");
-    encodemsg_jt65(x,CALL_IV3NWV,CALL_K1JT, GRID_BLANK);
-    qra64_encode(codec_k1jt, y, x);
-    rx = mfskchannel(y,channel_type,EbNodB);
-
-// Step 2b: IV3NWV attempts to decode [? ? ?], [IV3NWV ? ?] or [IV3NWV ?]
-    rc = qra64_decode(codec_iv3nwv, 0, xdec,rx);
-    if (rc>=0) { // decoded
-      printf("IV3NWV rx: received with apcode=%d %s\n",rc, decode_type[rc]);
-
-// Step 3a: IV3NWV replies to K1JT with a 73
-      printf("IV3NWV tx: K1JT   IV3NWV 73\n");
-      encodemsg_jt65(x,CALL_K1JT,CALL_IV3NWV, GRID_73);
-      qra64_encode(codec_iv3nwv, y, x);
-      rx = mfskchannel(y,channel_type,EbNodB);
-
-// Step 3b: K1JT attempts to decode [? ? ?] or [K1JT IV3NWV ?]
-      rc = qra64_decode(codec_k1jt, 0, xdec,rx);
-      if (rc>=0) { // decoded
-	printf("K1JT   rx: received with apcode=%d %s\n",rc, decode_type[rc]);
-
-// Step 4a: K1JT replies to IV3NWV with a 73
-	printf("K1JT   tx: IV3NWV K1JT   73\n");
-	encodemsg_jt65(x,CALL_IV3NWV,CALL_K1JT, GRID_73);
-	qra64_encode(codec_k1jt, y, x);
-	rx = mfskchannel(y,channel_type,EbNodB);
-
-// Step 4b: IV3NWV attempts to decode [? ? ?], [IV3NWV ? ?], or [IV3NWV ?]
-	rc = qra64_decode(codec_iv3nwv, 0, xdec,rx);
-	if (rc>=0) { // decoded
-	  printf("IV3NWV rx: received with apcode=%d %s\n",rc, decode_type[rc]);
-	  return 0;
-	}
-      }
-    }
-  }
-  printf("no decode\n");
-  return -1;
-}
-
-int test_proc_2(int channel_type, float EbNodB, int mode)
-{
-/*
-Here we simulate the decoder of K1JT after K1JT has sent a msg [IV3NWV K1JT]
-and IV3NWV sends him the msg [K1JT IV3NWV JN66].
-
-If mode=QRA_NOAP, K1JT decoder attempts to decode only msgs of type [? ? ?].
-
-If mode=QRA_AUTOP, K1JT decoder will attempt to decode also the msgs 
-[K1JT IV3NWV] and [K1JT IV3NWV ?].
-
-In the case a decode is successful the return code of the qra64_decode function
-indicates the amount of a-priori information required to decode the received 
-message according to this table:
-
- rc=0    [?    ?    ?]		AP0
- rc=1    [CQ   ?    ?]		AP27
- rc=2    [CQ   ?     ]		AP42
- rc=3    [CALL ?    ?]		AP29
- rc=4    [CALL ?     ]		AP44
- rc=5    [CALL CALL ?]		AP57
- rc=6    [?    CALL ?]		AP29
- rc=7    [?    CALL  ]		AP44
- rc=8    [CALL CALL GRID]	AP72
- rc=9    [CQ   CALL ?]		AP55
- rc=10   [CQ   CALL  ]		AP70
- rc=11   [CQ   CALL GRID]	AP70
-
-The return code is <0 when decoding is unsuccessful
-
-This test simulates the situation ntx times and reports how many times
-a particular type decode among the above 6 cases succeded.
-*/
-
-  int x[QRA64_K], xdec[QRA64_K];
-  int y[QRA64_N];
-  float *rx;
-  float ebnodbest, ebnodbavg=0;
-  int rc,k;
-
-  int ndecok[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-  int nundet = 0;
-  int ntx = 200,ndec=0;
-
-  qra64codec *codec_iv3nwv = qra64_init(mode);   // codec for IV3NWV
-  qra64codec *codec_k1jt   = qra64_init(mode);     // codec for K1JT
-
-  printf("\nQRA64 Test #2 - Decoding with AP knowledge (SNR-Eb/No offset = %.1f dB)\n\n",
-		   QRA64_SNR_EBNO_OFFSET);
-
-// This will enable K1JT's decoder to look for calls directed to him [K1JT ? ?/b]
-//  printf("K1JT decoder enabled for [K1JT  ?     ?/blank]\n");
-//  qra64_apset(codec_k1jt, CALL_K1JT,0,0,APTYPE_MYCALL);
-
-// This will enable K1JT's decoder to look for IV3NWV calls directed to him [K1JT IV3NWV ?/b]
-//  printf("K1JT decoder enabled for [K1JT IV3NWV ?]\n");
-//  qra64_apset(codec_k1jt, CALL_CQ,CALL_IV3NWV,0,APTYPE_BOTHCALLS);
-
-// This will enable K1JT's decoder to look for msges sent by IV3NWV [? IV3NWV ?]
-//  printf("K1JT decoder enabled for [?    IV3NWV ?/blank]\n");
-//  qra64_apset(codec_k1jt, 0,CALL_IV3NWV,GRID_BLANK,APTYPE_HISCALL);
-
-// This will enable K1JT's decoder to look for full-knowledge [K1JT IV3NWV JN66] msgs
-  printf("K1JT decoder enabled for [K1JT IV3NWV JN66]\n");
-  qra64_apset(codec_k1jt, CALL_K1JT,CALL_IV3NWV,GRID_JN66,APTYPE_FULL);
-
-// This will enable K1JT's decoder to look for calls from IV3NWV [CQ IV3NWV ?/b] msgs
-  printf("K1JT decoder enabled for [CQ   IV3NWV ?/b/JN66]\n");
-  qra64_apset(codec_k1jt, 0,CALL_IV3NWV,GRID_JN66,APTYPE_CQHISCALL);
-
-
-  // Dx station IV3NWV calls
-  printf("\nIV3NWV encoder sends msg: [K1JT IV3NWV JN66]\n\n");
-  encodemsg_jt65(x,CALL_CQ,CALL_IV3NWV,GRID_JN66);
-
-//  printf("\nIV3NWV encoder sends msg: [CQ IV3NWV JN66]\n\n");
-//  encodemsg_jt65(x,CALL_CQ,CALL_IV3NWV,GRID_JN66);
-
-//  printf("\nIV3NWV encoder sends msg: [CQ IV3NWV]\n\n");
-//  encodemsg_jt65(x,CALL_CQ,CALL_IV3NWV,GRID_BLANK);
-  qra64_encode(codec_iv3nwv, y, x);
-
-  printf("Simulating K1JT decoder up to AP72\n");
-
-  for (k=0;k<ntx;k++) {
-    printf(".");
-    rx = mfskchannel(y,channel_type,EbNodB);
-    rc = qra64_decode(codec_k1jt, &ebnodbest, xdec,rx);
-	if (rc>=0) {
-	  ebnodbavg +=ebnodbest;
-	  if (memcmp(xdec,x,12*sizeof(int))==0)
-		ndecok[rc]++;
-	  else
-	    nundet++;
-	}
-  }
-  printf("\n\n");
-
-
-  printf("Transimtted msgs:%d\nDecoded msgs:\n\n",ntx);
-  for (k=0;k<12;k++) {
-    printf("%3d with %s\n",ndecok[k],decode_type[k]);
-    ndec += ndecok[k];
-  }
-  printf("\nTotal: %d/%d (%d undetected errors)\n\n",ndec,ntx,nundet);
-  printf("");
-
-  ebnodbavg/=(ndec+nundet);
-  printf("Estimated SNR (average in dB) = %.2f dB\n\n",ebnodbavg-QRA64_SNR_EBNO_OFFSET);
-
-  return 0;
-}
-
-int test_fastfading(float EbNodB, float B90, int fadingModel, int submode, int apmode, int olddec, int channel_type, int ntx)
-{
-  int x[QRA64_K], xdec[QRA64_K];
-  int y[QRA64_N];
-  float *rx;
-  float ebnodbest, ebnodbavg=0;
-  int rc,k;
-  float rxolddec[QRA64_N*QRA64_M];	// holds the energies at nominal tone freqs
-
-  int ndecok[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-  int nundet = 0;
-  int ndec=0;
-
-  qra64codec *codec_iv3nwv; 
-  qra64codec *codec_k1jt; 
-
-  codec_iv3nwv=qra64_init(QRA_NOAP);  
-  codec_k1jt  =qra64_init(apmode);  
-
-  if (channel_type==2) {	// fast-fading case
-	printf("Simulating the fast-fading channel\n");
-	printf("B90=%.2f Hz - Fading Model=%s - Submode=QRA64%c\n",B90,fadingModel?"Lorentz":"Gauss",submode+'A');
-	printf("Decoder metric = %s\n",olddec?"AWGN":"Matched to fast-fading signal");
-	}
-  else {
-    printf("Simulating the %s channel\n",channel_type?"Rayleigh block fading":"AWGN");
-	printf("Decoder metric = AWGN\n");
-	}
-
-
-  printf("\nEncoding msg [K1JT IV3NWV JN66]\n");
-  encodemsg_jt65(x,CALL_K1JT,CALL_IV3NWV,GRID_JN66);
-// printf("[");
-//  for (k=0;k<11;k++) printf("%02hX ",x[k]); printf("%02hX]\n",x[11]);
-
-  qra64_encode(codec_iv3nwv, y, x);
-  printf("%d transmissions will be simulated\n\n",ntx);
-
-  if (apmode==QRA_USERAP) {
-	// This will enable K1JT's decoder to look for cq/qrz calls [CQ/QRZ ? ?/b]
-	printf("K1JT decoder enabled for [CQ    ?     ?/blank]\n");
-	qra64_apset(codec_k1jt, CALL_K1JT,0,0,APTYPE_CQQRZ);
-
-	// This will enable K1JT's decoder to look for calls directed to him [K1JT ? ?/b]
-	printf("K1JT decoder enabled for [K1JT  ?     ?/blank]\n");
-	qra64_apset(codec_k1jt, CALL_K1JT,0,0,APTYPE_MYCALL);
-
-	// This will enable K1JT's decoder to look for msges sent by IV3NWV [? IV3NWV ?]
-	printf("K1JT decoder enabled for [?    IV3NWV ?/blank]\n");
-	qra64_apset(codec_k1jt, 0,CALL_IV3NWV,GRID_BLANK,APTYPE_HISCALL);
-
-	// This will enable K1JT's decoder to look for IV3NWV calls directed to him [K1JT IV3NWV ?/b]
-	printf("K1JT decoder enabled for [K1JT IV3NWV ?]\n");
-	qra64_apset(codec_k1jt, CALL_K1JT,CALL_IV3NWV,0,APTYPE_BOTHCALLS);
-
-	// This will enable K1JT's decoder to look for full-knowledge [K1JT IV3NWV JN66] msgs
-	printf("K1JT decoder enabled for [K1JT IV3NWV JN66]\n");
-	qra64_apset(codec_k1jt, CALL_K1JT,CALL_IV3NWV,GRID_JN66,APTYPE_FULL);
-
-	// This will enable K1JT's decoder to look for calls from IV3NWV [CQ IV3NWV ?/b] msgs
-	printf("K1JT decoder enabled for [CQ   IV3NWV ?/b/JN66]\n");
-	qra64_apset(codec_k1jt, 0,CALL_IV3NWV,GRID_JN66,APTYPE_CQHISCALL);
-
-  }
-
-  printf("\nNow decoding with K1JT's decoder...\n");
-/*
-  if (channel_type==2) 	// simulate a fast-faded signal
-	  printf("Simulating a fast-fading channel with given B90 and spread type\n");
-  else
-	  printf("Simulating a %s channel\n",channel_type?"Rayleigh block fading":"AWGN");
-*/
-  for (k=0;k<ntx;k++) {
-
-	  if ((k%10)==0)
-	    printf("  %5.1f %%\r",100.0*k/ntx);
-//		printf(".");	// work in progress
-
-	if (channel_type==2) {	
-		// generate a fast-faded signal
-		rc = qra64_fastfading_channel(&rx,y,submode,EbNodB,B90,fadingModel);
-		if (rc<0) {
-			printf("\nqra64_fastfading_channel error. rc=%d\n",rc);
-			return -1;
-			}
-		}
-	else // generate a awgn or Rayleigh block fading signal
-		rx = mfskchannel(y, channel_type, EbNodB);
-
-
-	if (channel_type==2)	// fast-fading case
-		if (olddec==1) {
-			int k, j;
-			int jj = 1<<submode;
-			int bps = QRA64_M*(2+jj);
-			float *rxbase;
-			float *out = rxolddec;
-			// calc energies at nominal freqs
-			for (k=0;k<QRA64_N;k++) {
-				rxbase = rx + QRA64_M + k*bps;
-				for (j=0;j<QRA64_M;j++) {
-					*out++=*rxbase;
-					rxbase+=jj;
-					}
-				}
-			// decode with awgn decoder
-			rc = qra64_decode(codec_k1jt,&ebnodbest,xdec,rxolddec);
-			}
-		else // use fast-fading decoder
-			rc = qra64_decode_fastfading(codec_k1jt,&ebnodbest,xdec,rx,submode,B90,fadingModel);
-	else // awgn or rayleigh channel. use the old decoder whatever the olddec option is
-		rc = qra64_decode(codec_k1jt,&ebnodbest,xdec,rx);
-
-
-
-	if (rc>=0) {
-	  ebnodbavg +=ebnodbest;
-	  if (memcmp(xdec,x,12*sizeof(int))==0)
-		ndecok[rc]++;
-	  else {
-		fprintf(stderr,"\nUndetected error with rc=%d\n",rc);
-		nundet++;
-		}
-	  }
-
-  }
-  printf("  %5.1f %%\r",100.0*k/ntx);
-
-  printf("\n\n");
-
-  printf("Msgs transmitted:%d\nMsg decoded:\n\n",ntx);
-  for (k=0;k<12;k++) {
-    printf("rc=%2d   %3d with %s\n",k,ndecok[k],decode_type[k]);
-    ndec += ndecok[k];
-  }
-  printf("\nTotal: %d/%d (%d undetected errors)\n\n",ndec,ntx,nundet);
-  printf("");
-
-  if (ndec>0) {
-	ebnodbavg/=(ndec+nundet);
-	printf("Estimated SNR (average in dB) = %.2f dB\n\n",ebnodbavg-QRA64_SNR_EBNO_OFFSET);
-	}
-
-  return 0;
-}
-
-
-
-void syntax(void)
-{
-
-  printf("\nQRA64 Mode Tests\n");
-  printf("2016, Nico Palermo - IV3NWV\n\n");
-  printf("---------------------------\n\n");
-  printf("Syntax: qra64 [-s<snrdb>] [-c<channel>] [-a<ap-type>] [-t<testtype>] [-h]\n");
-  printf("Options: \n");
-  printf("       -s<snrdb>   : set simulation SNR in 2500 Hz BW (default:-27.5 dB)\n");
-  printf("       -c<channel> : set channel type 0=AWGN (default) 1=Rayleigh 2=Fast-fading\n");
-  printf("       -a<ap-type> : set decode type 0=NOAP 1=AUTOAP (default) 2=USERAP\n");
-  printf("       -t<testtype>: 0=simulate seq of msgs between IV3NWV and K1JT (default)\n");
-  printf("                     1=simulate K1JT receiving K1JT IV3NWV JN66\n");
-  printf("                     2=simulate fast-fading/awgn/rayliegh decoders performance\n");
-  printf("       -n<ntx>     : simulate the transmission of ntx codewords (default=100)\n");
-
-  printf("Options used only for fast-fading simulations (-c2):\n");
-  printf("       -b          : 90%% fading bandwidth in Hz [1..230 Hz] (default = 2.5 Hz)\n");
-  printf("       -m          : fading model. 0=Gauss, 1=Lorentz (default = Lorentz)\n");
-  printf("       -q          : qra64 submode. 0=QRA64A,... 4=QRA64E (default = QRA64A)\n");
-  printf("       -d          : use the old awgn decoder\n");
-  printf("       -h: this help\n");
-  printf("Example:\n");
-  printf("        qra64 -t2 -c2 -a2 -b50 -m1 -q2 -n10000 -s-26\n");
-  printf("        runs the error performance test (-t2)\n");
-  printf("        with USER_AP (-a2)\n");
-  printf("        simulating a fast fading channel (-c2)\n");
-  printf("        with B90 = 50 Hz (-b50), Lorentz Doppler (-m1), mode QRA64C (-q2)\n");
-  printf("        ntx = 10000 codewords (-n10000) and SNR = -26 dB (-s-26)\n");
-
-}
-
-int main(int argc, char* argv[])
-{
-  int k, rc, nok=0;
-  float SNRdB = -27.5f;
-  unsigned int channel = CHANNEL_AWGN;
-  unsigned int mode    = QRA_AUTOAP;
-  unsigned int testtype=0;
-  int   nqso = 100;
-  float EbNodB;
-  float B90 = 2.5;
-  int fadingModel = 1;
-  int submode = 0;
-  int olddec = 0;
-  int ntx = 100;
-
-// Parse the command line
-  while(--argc) {
-    argv++;
-
-    if (strncmp(*argv,"-h",2)==0) {
-      syntax();
-      return 0;
-	  } 
-	else 
-	if (strncmp(*argv,"-n",2)==0) {
-		ntx = ( int)atoi((*argv)+2);
-		if (ntx<100 || ntx>1000000) {
-			printf("Invalid -n option. ntx must be in the range [100..1000000]\n");
-			syntax();
-			return -1;
-			}
-		} 
-	else
-	if (strncmp(*argv,"-a",2)==0) {
-		mode = ( int)atoi((*argv)+2);
-		if (mode>2) {
-			printf("Invalid decoding mode\n");
-			syntax();
-			return -1;
-			}
-		} 
-	else
-	if (strncmp(*argv,"-s",2)==0) {
-		SNRdB = (float)atof((*argv)+2);
-		if (SNRdB>20 || SNRdB<-50) {
-			printf("SNR should be in the range [-50..20]\n");
-			syntax();
-			return -1;
-			}
-		} 
-	else 
-	if (strncmp(*argv,"-t",2)==0) {
-	    testtype = ( int)atoi((*argv)+2);
-	    if (testtype>2) {
-			printf("Invalid test type\n");
-			syntax();
-			return -1;
-			}
-		}
-	else 
-	if (strncmp(*argv,"-c",2)==0) {
-		channel = ( int)atoi((*argv)+2);
-	    if (channel>CHANNEL_FASTFADE) {
-			printf("Invalid channel type\n");
-			syntax();
-			return -1;
-			}
-	    } 
-	else
-	if (strncmp(*argv,"-b",2)==0) {
-	    B90 = (float)atof((*argv)+2);
-	    if (B90<1 || B90>230) {
-			printf("Invalid B90\n");
-			syntax();
-			return -1;
-			}
-		}
-	else
-	if (strncmp(*argv,"-m",2)==0) {
-	    fadingModel = (int)atoi((*argv)+2);
-	    if (fadingModel<0 || fadingModel>1) {
-			printf("Invalid fading model\n");
-			syntax();
-			return -1;
-			}
-		}
-	else
-	if (strncmp(*argv,"-q",2)==0) {
-	    submode = (int)atoi((*argv)+2);
-	    if (submode<0 || submode>4) {
-			printf("Invalid submode\n");
-			syntax();
-			return -1;
-			}
-		}
-	else
-	if (strncmp(*argv,"-d",2)==0) {
-		olddec = 1;
-		}
-	else {
-	    printf("Invalid option\n");
-	    syntax();
-	    return -1;
-	    }
-	}
-
-  if (testtype<2) // old tests
-	  if (channel==CHANNEL_FASTFADE) {
-		printf("Invalid Option. Test type 0 and 1 supports only AWGN or Rayleigh Channel model\n");
-		return -1;
-		}
-  
-  EbNodB = SNRdB+QRA64_SNR_EBNO_OFFSET;	
-  
-#if defined(__linux__) || defined(__unix__)
-  srand48(GetTickCount());
-#endif
-
-  if (testtype==0) {
-	for (k=0;k<nqso;k++) {
-		printf("\n\n------------------------\n");
-		rc = test_proc_1(channel, EbNodB, mode);
-		if (rc==0)
-			nok++;
-		}
-	printf("\n\n%d/%d QSOs to end without repetitions\n",nok,nqso);
-	printf("Input SNR = %.1fdB channel=%s ap-mode=%s\n\n",
-		SNRdB,
-		channel==CHANNEL_AWGN?"AWGN":"RAYLEIGH",
-		apmode_type[mode]
-		);
-	} 
-  else if (testtype==1) {
-	test_proc_2(channel, EbNodB, mode);
-	printf("Input SNR = %.1fdB channel=%s ap-mode=%s\n\n",
-		SNRdB,
-		channel==CHANNEL_AWGN?"AWGN":"RAYLEIGH",
-		apmode_type[mode]
-		);
-	}
-  else {
-	printf("Input SNR = %.1fdB ap-mode=%s\n\n",
-	 SNRdB,
-	 apmode_type[mode]
-	 );
-	test_fastfading(EbNodB,B90,fadingModel,submode,mode,olddec, channel, ntx);
-  }
-  return 0;
-}
diff --git a/lib/qra/qra64/qra64.c b/lib/qra/qra64/qra64.c
deleted file mode 100644
index 6470cedbd..000000000
--- a/lib/qra/qra64/qra64.c
+++ /dev/null
@@ -1,1121 +0,0 @@
-/*
-qra64.c 
-Encoding/decoding functions for the QRA64 mode
-
-(c) 2016 - Nico Palermo, IV3NWV
-
--------------------------------------------------------------------------------
-
-   qracodes 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.
-   qracodes 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 qracodes source distribution.  
-   If not, see <http://www.gnu.org/licenses/>.
-
------------------------------------------------------------------------------
-
-QRA code used in this sowftware release:
-
-QRA13_64_64_IRR_E: K=13 N=64 Q=64 irregular QRA code (defined in 
-qra13_64_64_irr_e.h /.c)
-
-Codes with K=13 are designed to include a CRC as the 13th information symbol
-and improve the code UER (Undetected Error Rate).
-The CRC symbol is not sent along the channel (the codes are punctured) and the 
-resulting code is a (12,63) code 
-*/
-//----------------------------------------------------------------------------
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "qra64.h"
-#include "../qracodes/qracodes.h"
-#include "../qracodes/qra13_64_64_irr_e.h"
-#include "../qracodes/pdmath.h"
-#include "../qracodes/normrnd.h"
-
-// Code parameters of the QRA64 mode 
-#define QRA64_CODE  qra_13_64_64_irr_e
-#define QRA64_NMSG  218        // Must much value indicated in QRA64_CODE.NMSG
-
-#define QRA64_KC (QRA64_K+1)   // Information symbols (crc included)
-#define QRA64_NC (QRA64_N+1)   // Codeword length (as defined in the code)
-#define QRA64_NITER 100	       // max number of iterations per decode
-
-// static functions declarations ----------------------------------------------
-static int  calc_crc6(const int *x, int sz);
-static void ix_mask(float *dst, const float *src, const int *mask, 
-		    const int *x);
-static int qra64_decode_attempts(qra64codec *pcodec, int *xdec, const float *ix);
-static int qra64_do_decode(int *x, const float *pix, const int *ap_mask, 
-			    const int *ap_x);
-static float qra64_fastfading_estim_noise_std(
-				const float *rxen, 
-				const float esnometric, 
-				const int submode);
-
-static void qra64_fastfading_intrinsics(
-				float *pix, 
-				const float *rxen, 
-				const float *hptr, 
-				const int    hlen, 
-				const float sigma,
-				const float EsNoMetric, 
-				const int submode);
-
-static float qra64_fastfading_msg_esno(
-			const int *ydec,
-			const float *rxen, 
-			const float sigma,
-			const float EsNoMetric,
-			const int hlen, 
-			const int submode);
-
-
-// a-priori information masks for fields in JT65-like msgs --------------------
-
-// when defined limits the AP masks to reduce the false decode rate
-#define LIMIT_AP_MASKS
-
-#ifdef LIMIT_AP_MASKS
-#define MASK_CQQRZ      0xFFFFFFC 
-#define MASK_CALL1      0xFFFFFFC
-#define MASK_CALL2      0xFFFFFFC
-#define MASK_GRIDFULL	0x3FFC
-#define MASK_GRIDFULL12	0x3FFC	  
-#define MASK_GRIDBIT	0x8000	  
-#else
-#define MASK_CQQRZ      0xFFFFFFC 
-#define MASK_CALL1      0xFFFFFFF
-#define MASK_CALL2      0xFFFFFFF
-#define MASK_GRIDFULL	0xFFFF
-#define MASK_GRIDFULL12	0x3FFC	  
-#define MASK_GRIDBIT	0x8000	  // b[15] is 1 for free text, 0 otherwise
-#endif
-
-// ----------------------------------------------------------------------------
-
-
-
-
-qra64codec *qra64_init(int flags)
-{
-
-  // Eb/No value for which we optimize the decoder metric
-  const float EbNodBMetric = 2.8f; 
-  const float EbNoMetric   = (float)pow(10,EbNodBMetric/10);
-  const float R = 1.0f*(QRA64_KC)/(QRA64_NC);	
-
-  qra64codec *pcodec = (qra64codec*)malloc(sizeof(qra64codec));
-
-  if (!pcodec)
-    return 0;	// can't allocate memory
-
-  pcodec->decEsNoMetric   = 1.0f*QRA64_m*R*EbNoMetric;
-  pcodec->apflags			= flags;
-
-  memset(pcodec->apmsg_set,0,APTYPE_SIZE*sizeof(int));
-
-  if (flags==QRA_NOAP)
-    return pcodec;
-
-  // for QRA_USERAP and QRA_AUTOAP modes we always enable [CQ/QRZ ? ?] mgs look-up.
-  // encode CQ/QRZ AP messages 
-  // NOTE: Here we handle only CQ and QRZ msgs. 
-  // 'CQ nnn', 'CQ DX' and 'DE' msgs will be handled by the decoder 
-  // as messages with no a-priori knowledge
-  qra64_apset(pcodec, CALL_CQ, 0, GRID_BLANK, APTYPE_CQQRZ);
-
-  // initialize masks for decoding with a-priori information
-  encodemsg_jt65(pcodec->apmask_cqqrz,     MASK_CQQRZ, 0, MASK_GRIDBIT);     
-  encodemsg_jt65(pcodec->apmask_cqqrz_ooo, MASK_CQQRZ, 0, MASK_GRIDFULL);
-  encodemsg_jt65(pcodec->apmask_call1,     MASK_CALL1, 0, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_call1_ooo, MASK_CALL1, 0, MASK_GRIDFULL);
-  encodemsg_jt65(pcodec->apmask_call2,     0, MASK_CALL2, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_call2_ooo, 0, MASK_CALL2, MASK_GRIDFULL);
-  encodemsg_jt65(pcodec->apmask_call1_call2,     MASK_CALL1,MASK_CALL2, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_call1_call2_grid,MASK_CALL1,MASK_CALL2, MASK_GRIDFULL12);
-  encodemsg_jt65(pcodec->apmask_cq_call2,     MASK_CQQRZ, MASK_CALL2, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_cq_call2_ooo, MASK_CQQRZ, MASK_CALL2, MASK_GRIDFULL12);
-
-  return pcodec;
-}
-
-void qra64_close(qra64codec *pcodec)
-{
-	free(pcodec);
-}
-
-int qra64_apset(qra64codec *pcodec, const int mycall, const int hiscall, const int grid, const int aptype)
-{
-// Set decoder a-priori knowledge accordingly to the type of the message to look up for
-// arguments:
-//		pcodec    = pointer to a qra64codec data structure as returned by qra64_init
-//		mycall    = mycall to look for
-//		hiscall   = hiscall to look for
-//		grid      = grid to look for
-//		aptype    = define and masks the type of AP to be set accordingly to the following:
-//			APTYPE_CQQRZ     set [cq/qrz ?       ?/blank]
-//			APTYPE_MYCALL    set [mycall ?       ?/blank]
-//			APTYPE_HISCALL   set [?      hiscall ?/blank]
-//			APTYPE_BOTHCALLS set [mycall hiscall ?]
-//			APTYPE_FULL		 set [mycall hiscall grid]
-//			APTYPE_CQHISCALL set [cq/qrz hiscall ?/blank] and [cq/qrz hiscall grid]
-// returns:
-//		0   on success
-//      -1  when qra64_init was called with the QRA_NOAP flag
-//		-2  invalid apytpe
-
-	if (pcodec->apflags==QRA_NOAP)
-		return -1;
-
-	switch (aptype) {
-		case APTYPE_CQQRZ:
-			encodemsg_jt65(pcodec->apmsg_cqqrz,  CALL_CQ, 0, GRID_BLANK);
-			break;
-		case APTYPE_MYCALL:
-			encodemsg_jt65(pcodec->apmsg_call1,  mycall,  0, GRID_BLANK);
-			break;
-		case APTYPE_HISCALL:
-			encodemsg_jt65(pcodec->apmsg_call2,  0, hiscall, GRID_BLANK);
-			break;
-		case APTYPE_BOTHCALLS:
-			encodemsg_jt65(pcodec->apmsg_call1_call2,  mycall, hiscall, GRID_BLANK);
-			break;
-		case APTYPE_FULL:
-			encodemsg_jt65(pcodec->apmsg_call1_call2_grid,  mycall, hiscall, grid);
-			break;
-		case APTYPE_CQHISCALL:
-			encodemsg_jt65(pcodec->apmsg_cq_call2,      CALL_CQ, hiscall, GRID_BLANK);
-			encodemsg_jt65(pcodec->apmsg_cq_call2_grid, CALL_CQ, hiscall, grid);
-			break;
-		default:
-			return -2;	// invalid ap type
-		}
-
-	  pcodec->apmsg_set[aptype]=1;	// signal the decoder to look-up for the specified type
-
-
-	  return 0;
-}
-void qra64_apdisable(qra64codec *pcodec, const int aptype)
-{
-	if (pcodec->apflags==QRA_NOAP)
-		return;
-
-	if (aptype<APTYPE_CQQRZ || aptype>=APTYPE_SIZE)
-		return;
-
-	pcodec->apmsg_set[aptype] = 0;	//  signal the decoder not to look-up to the specified type
-}
-
-void qra64_encode(qra64codec *pcodec, int *y, const int *x)
-{
-  int encx[QRA64_KC];	// encoder input buffer
-  int ency[QRA64_NC];	// encoder output buffer
-
-  int hiscall,mycall,grid;
-
-  memcpy(encx,x,QRA64_K*sizeof(int));		// Copy input to encoder buffer
-  encx[QRA64_K]=calc_crc6(encx,QRA64_K);	// Compute and add crc symbol
-  qra_encode(&QRA64_CODE, ency, encx);	 // encode msg+crc using given QRA code
-
-  // copy codeword to output puncturing the crc symbol 
-  memcpy(y,ency,QRA64_K*sizeof(int));		// copy information symbols 
-  memcpy(y+QRA64_K,ency+QRA64_KC,QRA64_C*sizeof(int)); // copy parity symbols 
-
-  if (pcodec->apflags!=QRA_AUTOAP)
-    return;
-
-  // Here we handle the QRA_AUTOAP mode --------------------------------------------
-
-  // When a [hiscall mycall ?] msg is detected we instruct the decoder
-  // to look for [mycall hiscall ?] msgs
-  // otherwise when a [cq mycall ?] msg is sent we reset the APTYPE_BOTHCALLS 
-
-  // look if the msg sent is a std type message (bit15 of grid field = 0)
-  if ((x[9]&0x80))
-    return;	// no, it's a text message, nothing to do
-
-  // It's a [hiscall mycall grid] message
-
-  // We assume that mycall is our call (but we don't check it)
-  // hiscall the station we are calling or a general call (CQ/QRZ/etc..)
-  decodemsg_jt65(&hiscall,&mycall,&grid,x);
-
-
-  if ((hiscall>=CALL_CQ && hiscall<=CALL_CQ999) || hiscall==CALL_CQDX || 
-      hiscall==CALL_DE) {
-	// tell the decoder to look for msgs directed to us
-	qra64_apset(pcodec,mycall,0,0,APTYPE_MYCALL);
-    // We are making a general call and don't know who might reply 
-    // Reset APTYPE_BOTHCALLS so decoder won't look for [mycall hiscall ?] msgs
-    qra64_apdisable(pcodec,APTYPE_BOTHCALLS);
-  } else {
-    // We are replying to someone named hiscall
-    // Set APTYPE_BOTHCALLS so decoder will try for [mycall hiscall ?] msgs
-    qra64_apset(pcodec,mycall, hiscall, GRID_BLANK, APTYPE_BOTHCALLS);
-  }
-
-}
-
-#define EBNO_MIN -10.0f		// minimum Eb/No value returned by the decoder (in dB)
-// AWGN metric decoder
-int qra64_decode(qra64codec *pcodec, float *ebno, int *x, const float *rxen)
-{
-  int k;
-  float *srctmp, *dsttmp;
-  float ix[QRA64_NC*QRA64_M];		// (depunctured) intrisic information
-  int   xdec[QRA64_KC];				// decoded message (with crc)
-  int   ydec[QRA64_NC];				// re-encoded message (for snr calculations)
-  float noisestd;					// estimated noise variance
-  float msge;						// estimated message energy
-  float ebnoval;					// estimated Eb/No
-  int rc;
-  
-  if (QRA64_NMSG!=QRA64_CODE.NMSG)      // sanity check 
-    return -16;				// QRA64_NMSG define is wrong
-
-  // compute symbols intrinsic probabilities from received energy observations
-  noisestd = qra_mfskbesselmetric(ix, rxen, QRA64_m, QRA64_N,pcodec->decEsNoMetric);
-
-  // de-puncture observations adding a uniform distribution for the crc symbol
-
-  // move check symbols distributions one symbol towards the end
-  dsttmp = PD_ROWADDR(ix,QRA64_M, QRA64_NC-1);	//Point to last symbol prob dist
-  srctmp = dsttmp-QRA64_M;              // source is the previous pd
-  for (k=0;k<QRA64_C;k++) {
-    pd_init(dsttmp,srctmp,QRA64_M);
-    dsttmp -=QRA64_M;
-    srctmp -=QRA64_M;
-  }
-  // Initialize crc prob to a uniform distribution
-  pd_init(dsttmp,pd_uniform(QRA64_m),QRA64_M);
-
-  // Try to decode using all AP cases if required
-  rc = qra64_decode_attempts(pcodec, xdec, ix);
-
-  if (rc<0)
-	  return rc;	// no success
-
-  // successfull decode --------------------------------
-  
-  // copy decoded message (without crc) to output buffer
-  memcpy(x,xdec,QRA64_K*sizeof(int));
-
-  if (ebno==0)	// null pointer indicates we are not interested in the Eb/No estimate
-	  return rc;
-
-  // reencode message and estimate Eb/No
-  qra_encode(&QRA64_CODE, ydec, xdec);	 
-  // puncture crc
-  memmove(ydec+QRA64_K,ydec+QRA64_KC,QRA64_C*sizeof(int)); 
-  // compute total power of decoded message
-  msge = 0;
-  for (k=0;k<QRA64_N;k++) {
-	  msge +=rxen[ydec[k]];	// add energy of current symbol
-	  rxen+=QRA64_M;			// ptr to next symbol
-	  }
-
-  // NOTE:
-  // To make a more accurate Eb/No estimation we should compute the noise variance
-  // on all the rxen values but the transmitted symbols.
-  // Noisestd is compute by qra_mfskbesselmetric assuming that
-  // the signal power is much less than the total noise power in the QRA64_M tones
-  // but this is true only if the Eb/No is low.
-  // Here, in order to improve accuracy, we linearize the estimated Eb/No value empirically
-  // (it gets compressed when it is very high as in this case the noise variance 
-  // is overestimated)
-
-  // this would be the exact value if the noisestd were not overestimated at high Eb/No
-  ebnoval = (0.5f/(QRA64_K*QRA64_m))*msge/(noisestd*noisestd)-1.0f; 
-
-  // Empirical linearization (to remove the noise variance overestimation)
-  // the resulting SNR is accurate up to +20 dB (51 dB Eb/No)
-  if (ebnoval>57.004f)
-	  ebnoval=57.004f;
-  ebnoval = ebnoval*57.03f/(57.03f-ebnoval);
-
-  // compute value in dB
-  if (ebnoval<=0) {
-    ebnoval = EBNO_MIN; // assume a minimum, positive value
-  }
-  else {
-    ebnoval = 10.0f*(float)log10(ebnoval);
-    if (ebnoval<EBNO_MIN) {
-      ebnoval = EBNO_MIN;
-    }
-  }
-  
-  *ebno = ebnoval;
-
-  return rc;	
-}
-
-//
-// Fast-fading / Rayleigh channel metric decoder ----------------------------------------------
-//
-// Tables of fading energies coefficients for QRA64 (Ts=6912/12000)
-// As the fading is assumed to be symmetric around the nominal frequency
-// only the leftmost and the central coefficient are stored in the tables.
-// (files have been generated with the Matlab code efgengaussenergy.m and efgenlorentzenergy.m)
-#include "fadengauss.c"
-#include "fadenlorentz.c"
-
-int qra64_decode_fastfading(
-				qra64codec *pcodec,		// ptr to the codec structure
-				float *ebno,			// ptr to where the estimated Eb/No value will be saved
-				int *x,					// ptr to decoded message 
-				const float *rxen,		// ptr to received symbol energies array
-				const int submode,		// submode idx (0=QRA64A ... 4=QRA64E)
-				const float B90,	    // spread bandwidth (90% fractional energy)
-				const int fadingModel)  // 0=Gaussian 1=Lorentzian fade model
-
-// Decode a QRA64 msg using a fast-fading metric
-//
-// rxen: The array of the received bin energies
-//       Bins must be spaced by integer multiples of the symbol rate (1/Ts Hz)
-//       The array must be an array of total length U = L x N where:
-//			L: is the number of frequency bins per message symbol (see after)
-//          N: is the number of symbols in a QRA64 msg (63)
-
-//       The number of bins/symbol L depends on the selected submode accordingly to 
-//		 the following rule:
-//			L = (64+64*2^submode+64) = 64*(2+2^submode)
-//		 Tone 0 is always supposed to be at offset 64 in the array.
-//		 The m-th tone nominal frequency is located at offset 64 + m*2^submode (m=0..63)
-//
-//		 Submode A: (2^submode = 1)
-//          L = 64*3 = 196 bins/symbol
-//          Total length of the energies array: U = 192*63 = 12096 floats
-//
-//		 Submode B: (2^submode = 2)
-//          L = 64*4 = 256 bins/symbol
-//          Total length of the energies array: U = 256*63 = 16128 floats
-//
-//		 Submode C: (2^submode = 4)
-//          L = 64*6 = 384 bins/symbol
-//          Total length of the energies array: U = 384*63 = 24192 floats
-//
-//		 Submode D: (2^submode = 8)
-//          L = 64*10 = 640 bins/symbol
-//          Total length of the energies array: U = 640*63 = 40320 floats
-//
-//		 Submode E: (2^submode = 16)
-//          L = 64*18 = 1152 bins/symbol
-//          Total length of the energies array: U = 1152*63 = 72576 floats
-//
-//		Note: The rxen array is modified and reused for internal calculations.
-//
-//
-//	B90: spread fading bandwidth in Hz (90% fractional average energy)
-//
-//			B90 should be in the range 1 Hz ... 238 Hz
-//			The value passed to the call is rounded to the closest value among the 
-//			64 available values:
-//				B = 1.09^k Hz, with k=0,1,...,63
-//
-//			I.e. B90=27 Hz will be approximated in this way:
-//				k = rnd(log(27)/log(1.09)) = 38
-//              B90 = 1.09^k = 1.09^38 = 26.4 Hz
-//
-//          For any input value the maximum rounding error is not larger than +/- 5%
-//          
-
-{
-
-  int k;
-  float *srctmp, *dsttmp;
-  float ix[QRA64_NC*QRA64_M];		// (depunctured) intrisic information
-  int   xdec[QRA64_KC];				// decoded message (with crc)
-  int   ydec[QRA64_NC];				// re-encoded message (for snr calculations)
-  float noisestd;					// estimated noise std
-  float esno,ebnoval;				// estimated Eb/No
-  float tempf;
-  float EsNoMetric;
-
-  int rc;
-  int hidx, hlen;
-  const float *hptr;
-  
-	if (QRA64_NMSG!=QRA64_CODE.NMSG)
-		return -16;					// QRA64_NMSG define is wrong
-
-	if (submode<0 || submode>4)
-		return -17;				// invalid submode
-
-	if (B90<1.0f || B90>238.0f)	
-		return -18;				// B90 out of range
-
-	// compute index to most appropriate amplitude weighting function coefficients
-    hidx = (int)(log((float)B90)/log(1.09f) - 0.499f);
-
-	if (hidx<0 || hidx > 64) 
-		return -19;				// index of weighting function out of range
-
-	if (fadingModel==0) {	 // gaussian fading model
-		// point to gaussian energy weighting taps
-		hlen = glen_tab_gauss[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = gptr_tab_gauss[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else if (fadingModel==1) {
-		// point to lorentzian energy weighting taps
-		hlen = glen_tab_lorentz[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = gptr_tab_lorentz[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else 
-		return -20;			// invalid fading model index
-
-
-	// compute (euristically) the optimal decoder metric accordingly the given spread amount
-	// We assume that the decoder threshold is:
-	//		Es/No(dB) = Es/No(AWGN)(dB) + 8*log(B90)/log(240)(dB)
-	// that's to say, at the maximum Doppler spread bandwidth (240 Hz) there's a ~8 dB Es/No degradation
-	// over the AWGN case
-	tempf = 8.0f*(float)log((float)B90)/(float)log(240.0f);
-	EsNoMetric = pcodec->decEsNoMetric*(float)pow(10.0f,tempf/10.0f);
-
-
-
-	// Step 1 ----------------------------------------------------------------------------------- 
-	// Evaluate the noise stdev from the received energies at nominal tone frequencies
-	noisestd = qra64_fastfading_estim_noise_std(rxen, EsNoMetric, submode);
-
-	// Step 2 -----------------------------------------------------------------------------------
-	// Compute message symbols probability distributions
-	qra64_fastfading_intrinsics(ix, rxen, hptr, hlen, noisestd, EsNoMetric, submode);
-
-	// Step 3 ---------------------------------------------------------------------------
-	// De-puncture observations adding a uniform distribution for the crc symbol
-	// Move check symbols distributions one symbol towards the end
-	dsttmp = PD_ROWADDR(ix,QRA64_M, QRA64_NC-1);	//Point to last symbol prob dist
-	srctmp = dsttmp-QRA64_M;              // source is the previous pd
-	for (k=0;k<QRA64_C;k++) {
-		pd_init(dsttmp,srctmp,QRA64_M);
-		dsttmp -=QRA64_M;
-		srctmp -=QRA64_M;
-		}
-	// Initialize crc prob to a uniform distribution
-	pd_init(dsttmp,pd_uniform(QRA64_m),QRA64_M);
-
-	// Step 4 ---------------------------------------------------------------------------
-	// Attempt to decode
-	rc = qra64_decode_attempts(pcodec, xdec, ix);
-	if (rc<0)
-	  return rc;	// no success
-
-	// copy decoded message (without crc) to output buffer
-	memcpy(x,xdec,QRA64_K*sizeof(int));
-
-	// Step 5 ----------------------------------------------------------------------------
-	// Estimate the message Eb/No
-
-	if (ebno==0)	// null pointer indicates we are not interested in the Eb/No estimate
-		return rc;
-
-	// reencode message to estimate Eb/No
-	qra_encode(&QRA64_CODE, ydec, xdec);	 
-	// puncture crc
-	memmove(ydec+QRA64_K,ydec+QRA64_KC,QRA64_C*sizeof(int)); 
-
-	// compute Es/N0 of decoded message
-	esno = qra64_fastfading_msg_esno(ydec,rxen,noisestd, EsNoMetric, hlen,submode);
-
-	// as the weigthing function include about 90% of the energy
-	// we could compute the unbiased esno with:
-	// esno = esno/0.9;
-	
-	// Es/N0 --> Eb/N0 conversion
-	ebnoval = 1.0f/(1.0f*QRA64_K/QRA64_N*QRA64_m)*esno; 
-
-	// compute value in dB
-	if (ebnoval<=0) {
-	  ebnoval = EBNO_MIN; // assume a minimum, positive value
-    }
-	else {
-	  ebnoval = 10.0f*(float)log10(ebnoval);
-	  if (ebnoval<EBNO_MIN) {
-		  ebnoval = EBNO_MIN;
-      }
-    }
-  
-	*ebno = ebnoval;
-
-  return rc;	
-
-}
-
-
-/*
-int qra64_fastfading_channel(float **rxen, const int *xmsg, const int submode, const float EbN0dB, const float B90, const int fadingModel)
-{
-	// Simulate transmission over a fading channel and non coherent detection
-
-	// Set rxen to point to an array of bin energies formatted as required 
-	// by the (fast-fading) decoding routine
-
-	// returns 0 on success or negative values on error conditions
-
-	static float *channel_out = NULL;
-	static int    channel_submode = -1;
-
-	int bpt = (1<<submode);			// bins per tone 
-	int bps = QRA64_M*(2+bpt);		// total number of bins per symbols
-	int bpm = bps*QRA64_N;			// total number of bins in a message
-	int n,j,hidx, hlen;
-	const float *hptr;
-	float *cursym,*curtone;
-
-	float iq[2];
-	float *curi, *curq;
-	float sigmasig[65];	// signal standard deviation taps
-
-	float N0, EsN0, Es, sigmanoise;
-
-	if (rxen==NULL)
-		return -1;		// rxen must be a non-null ptr 
-
-	// allocate output buffer if not yet done or if submode changed
-	if (channel_out==NULL || submode!=channel_submode) {
-
-		// unallocate previous buffer
-		if (channel_out)
-			free(channel_out);
-
-		// allocate new buffer
-		// we allocate twice the mem so that we can store/compute complex amplitudes
-		channel_out = (float*)malloc(bpm*sizeof(float)*2);	
-		if (channel_out==NULL)
-			return -2;	// error allocating memory
-
-		channel_submode = submode;
-		}
-
-	if (B90<1.0f || B90>238.0f)	
-		return -18;				// B90 out of range
-
-	// compute index to most appropriate energy weighting function coefficients
-    hidx = (int)(log((float)B90)/log(1.09f) - 0.499f);
-
-	if (hidx<0 || hidx > 64) 
-		return -19;				// index of weighting function out of range
-
-	if (fadingModel==0) {	 // gaussian fading model
-		// point to gaussian weighting taps
-		hlen = glen_tab_gauss[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = gptr_tab_gauss[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else if (fadingModel==1) {
-		// point to lorentzian weighting taps
-		hlen = glen_tab_lorentz[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = gptr_tab_lorentz[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else 
-		return -20;			// invalid fading model index
-
-
-	// Compute the unfaded tone amplitudes from the Eb/No value passed to the call
-	N0 = 1.0f;	// assume unitary noise PSD
-	sigmanoise = (float)sqrt(N0/2);
-	EsN0 = (float)pow(10.0f,EbN0dB/10.0f)*QRA64_m*QRA64_K/QRA64_N; // Es/No = m*R*Eb/No
-	Es   = EsN0*N0;
-
-	// compute signal bin sigmas
-	for (n=0;n<hlen;n++)
-		sigmasig[n] = (float)sqrt(hptr[n]*Es/2.0f);
-
-	// Generate gaussian noise iq components
-	normrnd_s(channel_out, bpm*2, 0 , sigmanoise);
-
-	// Add symbols, bin by bin energies
-	for (n=0;n<QRA64_N;n++) {					
-
-		cursym  = channel_out+n*bps + QRA64_M; // point to n-th symbol
-		curtone = cursym+xmsg[n]*bpt;	 // point to encoded tone 
-		curi    = curtone-hlen+1;		 // point to real part of first bin
-		curq    = curtone-hlen+1+bpm;	 // point to imag part of first bin
-		
-		// generate Rayleigh faded bins with given average energy and add to noise
-		for (j=0;j<hlen;j++) {	
-			normrnd_s(iq, 2, 0 , sigmasig[j]);
-			*curi++ += iq[0];
-			*curq++ += iq[1];
-			}
-		for (j=hlen-2;j>=0;j--) {	
-			normrnd_s(iq, 2, 0 , sigmasig[j]);
-			*curi++ += iq[0];
-			*curq++ += iq[1];
-			}
-
-		}
-
-	// compute total bin energies (S+N) and store in first half of buffer
-	curi = channel_out;
-	curq = channel_out+bpm;
-	for (n=0;n<bpm;n++) 					
-		channel_out[n] = curi[n]*curi[n] + curq[n]*curq[n];
-
-	// set rxen to point to the channel output energies
-	*rxen = channel_out;
-
-	return 0;	
-}
-*/
-
-
-// Static functions definitions ----------------------------------------------
-
-// fast-fading static functions --------------------------------------------------------------
-
-static float qra64_fastfading_estim_noise_std(const float *rxen, const float esnometric, const int submode)
-{
-	// estimate the noise standard deviation from nominal frequency symbol bins
-	// transform energies to amplitudes
-
-	// rxen = message symbols energies (overwritten with symbols amplitudes)
-	// esnometric = Es/No at nominal frequency bin for which we compute the decoder metric
-	// submode = submode used (0=A...4=E)
-
-	int bpt = (1<<submode);			// bins per tone 
-	int bps = QRA64_M*(2+bpt);		// total number of bins per symbols
-	int bpm = bps*QRA64_N;			// total number of bins in a message
-	int k;
-	float sigmaest;
-
-	// estimate noise std
-	sigmaest = 0;
-	for (k=0;k<bpm;k++) 
-		sigmaest += rxen[k];
-
-	sigmaest = sigmaest/bpm;
-	sigmaest = (float)sqrt(sigmaest/(1.0f+esnometric/bps)/2.0f); 
-
-	// Note: sigma is overestimated by the (unknown) factor sqrt((1+esno(true)/bps)/(1+esnometric/bps))
-
-	return sigmaest;
-}
-
-static void qra64_fastfading_intrinsics(
-				float *pix, 
-				const float *rxen, 
-				const float *hptr, 
-				const int    hlen, 
-				const float sigmaest,
-				const float EsNoMetric, 
-				const int submode)
-{
-
-	// For each symbol in a message:
-	// a) Compute tones loglikelihoods as a sum of products between of the expected 
-	// energy fading coefficient and received energies.
-	// b) Compute intrinsic symbols probability distributions from symbols loglikelihoods
-
-	int n,k,j, bps, bpt;
-	const float *cursym, *curbin;
-	float *curix;
-	float u, maxloglh, loglh, sumix,hh;
-	float w[65];
-	int hhsz  = hlen-1;
-	int hlast = 2*hhsz;
-	float npwrest = 2.0f*sigmaest*sigmaest;
-
-	bpt = 1<<submode;				// bins per tone
-	bps = QRA64_M*(2+bpt);			// bins per symbol
-
-	u = EsNoMetric;
-	// compute weights from energy tables
-	for (j=0;j<hlen;j++) {	
-		hh = hptr[j]*u; 
-		w[j] = hh/(1+hh)/npwrest;
-		}
-
-	for (n=0;n<QRA64_N;n++) {			// for each symbol in the message
-		cursym = rxen+n*bps + QRA64_M;	// point to current symbol nominal bin
-		maxloglh = 0;
-		curix  = pix+n*QRA64_M;		
-		for (k=0;k<QRA64_M;k++) {   // for each tone in the current symbol
-			curbin = cursym + k*bpt -hlen+1;
-			// compute tone loglikelihood (symmetric fir with given weights)
-			loglh = 0.f;
-			for (j=0;j<hhsz;j++) 
-				loglh += w[j]*(curbin[j] + curbin[hlast-j]);	
-			loglh += w[hhsz]*curbin[hhsz];
-
-			if (loglh>maxloglh)		// keep track of the max loglikelihood
-				maxloglh = loglh;
-			curix[k]=loglh;
-			}
-
-		// scale to likelihoods
-		sumix = 0.f;
-		for (k=0;k<QRA64_M;k++) {   
-			u = (float)exp(curix[k]-maxloglh);
-			curix[k]=u;
-			sumix +=u;
-			}
-		// scale to probabilities
-		sumix = 1.0f/sumix;
-		for (k=0;k<QRA64_M;k++) 
-			curix[k] = curix[k]*sumix;
-		}
-}
-
-static float qra64_fastfading_msg_esno(
-			const int *ydec,
-			const float *rxen, 
-			const float sigma,
-			const float EsNoMetric,
-			const int hlen, 
-			const int submode)
-{
-	// Estimate msg Es/N0
-
-	int n,j, bps, bpt;
-	const float *cursym, *curtone, *curbin;
-	float u, msgsn,esno;
-	int tothlen = 2*hlen-1;
-
-	bpt = 1<<submode;				// bins per tone
-	bps = QRA64_M*(2+bpt);			// bins per symbol
-
-	msgsn = 0;
-	for (n=0;n<QRA64_N;n++) {					
-		cursym  = rxen+n*bps + QRA64_M; // point to n-th symbol amplitudes
-		curtone = cursym+ydec[n]*bpt;	 // point to decoded tone amplitudes
-		curbin  = curtone-hlen+1;		 // point to first bin amplitude
-		
-		// sum bin energies
-		for (j=0;j<tothlen;j++)
-			msgsn += curbin[j];		
-
-		}
-
-	msgsn =  msgsn/(QRA64_N*tothlen);	// avg msg energy per bin (noise included)
-
-	// as sigma is overestimated (sigmatrue = sigma*sqrt((1+EsNoMetric/bps)/(1+EsNo/bps))
-	// we have: msgsn = (1+x/hlen)/(1+x/bps)*2*sigma^2*(1+EsnoMetric/bps), where x = Es/N0(true)
-	//
-	// we can then write:
-	// u = msgsn/2.0f/(sigma*sigma)/(1.0f+EsNoMetric/bps);
-	// (1+x/hlen)/(1+x/bps) = u
-
-	u = msgsn/(2.0f*sigma*sigma)/(1.0f+EsNoMetric/bps);
-
-	// check u>1 
-	if (u<1)
-		return 0.f;
-
-	// check u<bps/tot hlen
-	if (u>(bps/tothlen))
-		return 10000.f;
-
-	// solve for Es/No
-	esno = (u-1.0f)/(1.0f/tothlen-u/bps);
-
-	return esno;
-	
-
-}
-
-#ifdef LIMIT_AP_MASKS
-
-static int call1_match(const int *papmsg, const int *pdec)
-{
-	// assumes MASK_CALL1   =   0xFFFFFFC
-	int u = papmsg[4]^pdec[4];
-	return (u&0x3C)==0;
-}
-static int call2_match(const int *papmsg, const int *pdec)
-{
-	// assumes MASK_CALL2   =   0xFFFFFFC
-	int u = papmsg[9]^pdec[9];
-	return  (u&0x30)==0;
-}
-static int grid_match(const int *papmsg, const int *pdec)
-{
-	// assumes MASK_GRIDFULL =	0x3FFC
-	int u = papmsg[11]^pdec[11];
-	int rc = (u&0x03)==0;
-
-	u = papmsg[9]^pdec[9];
-
-	return (u&0x0C)==0 && rc;
-}
-
-#else
-#define call1_match(a,b) (1)
-#define call2_match(a,b) (1)
-#define grid_match(a,b) (1)
-#endif
-
-
-
-
-// Attempt to decode given intrisic information
-static int qra64_decode_attempts(qra64codec *pcodec, int *xdec, const float *ix)
-{
-  int rc;
-
-  // Attempt to decode without a-priori info --------------------------------
-  rc = qra64_do_decode(xdec, ix, NULL, NULL);
-  if (rc>=0) 
-	  return 0; // successfull decode with AP0
-  else
-	  if (pcodec->apflags==QRA_NOAP) 
-		  // nothing more to do
-		  return rc; // rc<0 = unsuccessful decode
-
-  // Here we handle decoding with AP knowledge
-
-
-  // Attempt to decode CQ calls
-  rc = qra64_do_decode(xdec,ix,pcodec->apmask_cqqrz, pcodec->apmsg_cqqrz); 
-  if (rc>=0) 
-	  return 1;    // decoded [cq/qrz ? ?]
-
-  rc = qra64_do_decode(xdec, ix, pcodec->apmask_cqqrz_ooo, 
-		       pcodec->apmsg_cqqrz);	                        
-  if (rc>=0) 
-	  // check that ooo really matches
-	  if (grid_match(pcodec->apmsg_cqqrz,xdec))
-		  return 2;    // decoded [cq/qrz ? ooo]
-
-  // attempt to decode calls directed to us 
-  if (pcodec->apmsg_set[APTYPE_MYCALL]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1, 
-		       pcodec->apmsg_call1);		                
-	if (rc>=0) 
-		// check that mycall really matches
-		if (call1_match(pcodec->apmsg_call1,xdec))
-			return 3;    // decoded [mycall ? ?]
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1_ooo, 
-		       pcodec->apmsg_call1);	                    
-	if (rc>=0) 
-		// check that mycall and ooo really match
-		if (call1_match(pcodec->apmsg_call1,xdec) && 
-			grid_match(pcodec->apmsg_call1,xdec))
-			return 4;    // decoded [mycall ? ooo]
-	}
-
-  // attempt to decode [mycall hiscall ?] msgs
-  if (pcodec->apmsg_set[APTYPE_BOTHCALLS]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1_call2, 
-		       pcodec->apmsg_call1_call2);	                
-	if (rc>=0) 
-		// check that mycall and hiscall really match
-		if (call1_match(pcodec->apmsg_call1_call2,xdec) && 
-			call2_match(pcodec->apmsg_call1_call2,xdec))
-			return 5;    // decoded [mycall srccall ?]	
-	}
-
-  // attempt to decode [? hiscall ?/b] msgs
-  if (pcodec->apmsg_set[APTYPE_HISCALL]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call2, 
-		       pcodec->apmsg_call2);		                
-	if (rc>=0) 
-		// check that hiscall really match
-		if (call2_match(pcodec->apmsg_call2,xdec))
-			return 6;    // decoded [? hiscall ?]
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call2_ooo, 
-		       pcodec->apmsg_call2);	                    
-	if (rc>=0) 
-		// check that hiscall and ooo match
-		if (call2_match(pcodec->apmsg_call2,xdec) &&
-			grid_match(pcodec->apmsg_call2,xdec))
-			return 7;    // decoded [? hiscall ooo]
-	}
-
-  // attempt to decode [cq/qrz hiscall ?/b/grid] msgs
-  if (pcodec->apmsg_set[APTYPE_CQHISCALL]) {
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_cq_call2, 
-				pcodec->apmsg_cq_call2);		                
-	if (rc>=0) 
-		// check that hiscall matches
-		if (call2_match(pcodec->apmsg_call2,xdec))
-			return 9;	// decoded [cq/qrz hiscall ?]
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_cq_call2_ooo, 
-		       pcodec->apmsg_cq_call2_grid);	
-	if (rc>=0) {
-		// Full AP mask need special handling
-		// To minimize false decodes we check the decoded message
-		// with what passed in the ap_set call
-		if (memcmp(pcodec->apmsg_cq_call2_grid,xdec, QRA64_K*sizeof(int))==0) 
-			return 11;		// decoded [cq/qrz hiscall grid]
-		}    
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_cq_call2_ooo, 
-		       pcodec->apmsg_cq_call2);	                    
-	if (rc>=0) { 
-		// Full AP mask need special handling
-		// To minimize false decodes we check the decoded message
-		// with what passed in the ap_set call
-		if (memcmp(pcodec->apmsg_cq_call2,xdec, QRA64_K*sizeof(int))==0) 
-			return 10;    // decoded [cq/qrz hiscall ]
-		}
-	}
-
-  // attempt to decode [mycall hiscall grid]
-  if (pcodec->apmsg_set[APTYPE_FULL]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1_call2_grid, 
-		       pcodec->apmsg_call1_call2_grid); 
-	if (rc>=0) { 
-		// Full AP mask need special handling
-		// All the three msg fields were given.
-		// To minimize false decodes we check the decoded message
-		// with what passed in the ap_set call
-		if (memcmp(pcodec->apmsg_call1_call2_grid,xdec, QRA64_K*sizeof(int))==0) 
-			return 8;	   // decoded [mycall hiscall grid]
-		}
-	}
-
-  // all decoding attempts failed
-  return -1;
-}
-
-
-
-// Decode with given a-priori information 
-static int qra64_do_decode(int *xdec, const float *pix, const int *ap_mask, 
-			   const int *ap_x)
-{
-  int rc;
-  const float *ixsrc;
-  float ix_masked[QRA64_NC*QRA64_M];  // Masked intrinsic information
-  float ex[QRA64_NC*QRA64_M];	      // Extrinsic information from the decoder
-
-  float v2cmsg[QRA64_NMSG*QRA64_M];   // buffers for the decoder messages
-  float c2vmsg[QRA64_NMSG*QRA64_M];
-
-  if (ap_mask==NULL) {   // no a-priori information
-    ixsrc = pix;	 // intrinsic source is what passed as argument
-  } else {	
-    // a-priori information provided
-    // mask channel observations with a-priori 
-    ix_mask(ix_masked,pix,ap_mask,ap_x);
-    ixsrc = ix_masked;	// intrinsic source is the masked version
-  }
-
-  // run the decoding algorithm
-  rc = qra_extrinsic(&QRA64_CODE,ex,ixsrc,QRA64_NITER,v2cmsg,c2vmsg);
-  if (rc<0)
-    return -1;	// no convergence in given iterations
-
-  // decode 
-  qra_mapdecode(&QRA64_CODE,xdec,ex,ixsrc);
-
-  // verify crc
-  if (calc_crc6(xdec,QRA64_K)!=xdec[QRA64_K]) // crc doesn't match (detected error)
-    return -2;	// decoding was succesfull but crc doesn't match
-
-  return 0;
-}
-
-
-// crc functions --------------------------------------------------------------
-// crc-6 generator polynomial
-// g(x) = x^6 + a5*x^5 + ... + a1*x + a0
-
-// g(x) = x^6 + x + 1  
-#define CRC6_GEN_POL 0x30  // MSB=a0 LSB=a5    
-
-// g(x) = x^6 + x^2 + x + 1 (See:  https://users.ece.cmu.edu/~koopman/crc/)
-// #define CRC6_GEN_POL 0x38  // MSB=a0 LSB=a5. Simulation results are similar
-
-static int calc_crc6(const int *x, int sz)
-{
-  // todo: compute it faster using a look up table
-  int k,j,t,sr = 0;
-  for (k=0;k<sz;k++) {
-    t = x[k];
-    for (j=0;j<6;j++) {
-      if ((t^sr)&0x01)
-	sr = (sr>>1) ^ CRC6_GEN_POL;
-      else
-	sr = (sr>>1);
-      t>>=1;
-    }
-  }
-  return sr;
-}
-
-static void ix_mask(float *dst, const float *src, const int *mask, 
-		    const int *x)
-{
-  // mask intrinsic information (channel observations) with a priori knowledge
-	
-  int k,kk, smask;
-  float *row;
-
-  memcpy(dst,src,(QRA64_NC*QRA64_M)*sizeof(float));
-
-  for (k=0;k<QRA64_K;k++) {	// we can mask only information symbols distrib
-    smask = mask[k];
-    row = PD_ROWADDR(dst,QRA64_M,k);
-    if (smask) {
-      for (kk=0;kk<QRA64_M;kk++) 
-	if (((kk^x[k])&smask)!=0)
-	  *(row+kk) = 0.f;
-
-      pd_norm(row,QRA64_m);
-    }
-  }
-}
-
-// encode/decode msgs as done in JT65
-void encodemsg_jt65(int *y, const int call1, const int call2, const int grid)
-{
-  y[0]= (call1>>22)&0x3F;
-  y[1]= (call1>>16)&0x3F;
-  y[2]= (call1>>10)&0x3F;
-  y[3]= (call1>>4)&0x3F;
-  y[4]= (call1<<2)&0x3F;
-
-  y[4] |= (call2>>26)&0x3F;
-  y[5]= (call2>>20)&0x3F;
-  y[6]= (call2>>14)&0x3F;
-  y[7]= (call2>>8)&0x3F;
-  y[8]= (call2>>2)&0x3F;
-  y[9]= (call2<<4)&0x3F;
-
-  y[9] |= (grid>>12)&0x3F;
-  y[10]= (grid>>6)&0x3F;
-  y[11]= (grid)&0x3F;
-
-}
-void decodemsg_jt65(int *call1, int *call2, int *grid, const int *x)
-{
-  int nc1, nc2, ng;
-
-  nc1 = x[4]>>2;
-  nc1 |= x[3]<<4;
-  nc1 |= x[2]<<10;
-  nc1 |= x[1]<<16;
-  nc1 |= x[0]<<22;
-
-  nc2 = x[9]>>4;
-  nc2 |= x[8]<<2;
-  nc2 |= x[7]<<8;
-  nc2 |= x[6]<<14;
-  nc2 |= x[5]<<20;
-  nc2 |= (x[4]&0x03)<<26;
-
-  ng   = x[11];
-  ng  |= x[10]<<6;
-  ng  |= (x[9]&0x0F)<<12;
-
-  *call1 = nc1;
-  *call2 = nc2;
-  *grid  = ng;
-}
diff --git a/lib/qra/qra64/qra64.h b/lib/qra/qra64/qra64.h
deleted file mode 100644
index 3b2b5bd3d..000000000
--- a/lib/qra/qra64/qra64.h
+++ /dev/null
@@ -1,269 +0,0 @@
-// qra64.h
-// Encoding/decoding functions for the QRA64 mode
-// 
-// (c) 2016 - Nico Palermo, IV3NWV 
-// ------------------------------------------------------------------------------
-// This file is part of the qracodes project, a Forward Error Control
-// encoding/decoding package based on Q-ary RA (Repeat and Accumulate) LDPC codes.
-//
-//    qracodes 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.
-//    qracodes 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 qracodes source distribution.  
-//    If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef _qra64_h_
-#define _qra64_h_
-
-// qra64_init(...) initialization flags
-#define QRA_NOAP     0	// don't use a-priori knowledge
-#define QRA_AUTOAP   1	// use  auto a-priori knowledge 
-#define QRA_USERAP   2	// a-priori knowledge messages provided by the user
-
-// QRA code parameters
-#define QRA64_K  12	// information symbols
-#define QRA64_N  63	// codeword length
-#define QRA64_C  51	// (number of parity checks C=(N-K))
-#define QRA64_M  64	// code alphabet size
-#define QRA64_m  6	// bits per symbol
-
-// packed predefined callsigns and fields as defined in JT65
-#define CALL_CQ		0xFA08319 
-#define CALL_QRZ	0xFA0831A 
-#define CALL_CQ000      0xFA0831B
-#define CALL_CQ999      0xFA08702
-#define CALL_CQDX	0x5624C39
-#define CALL_DE  	0xFF641D1
-#define GRID_BLANK	0x7E91
-
-// Types of a-priori knowledge messages
-#define APTYPE_CQQRZ     0  // [cq/qrz ?       ?/blank]
-#define APTYPE_MYCALL    1  // [mycall ?       ?/blank]
-#define APTYPE_HISCALL   2  // [?      hiscall ?/blank]
-#define APTYPE_BOTHCALLS 3  // [mycall hiscall ?]
-#define APTYPE_FULL	 4  // [mycall hiscall grid]
-#define APTYPE_CQHISCALL 5  // [cq/qrz hiscall ?/blank]
-#define APTYPE_SIZE	(APTYPE_CQHISCALL+1)
-
-typedef struct {
-  float decEsNoMetric;
-  int apflags;
-  int apmsg_set[APTYPE_SIZE];     // indicate which ap type knowledge has 
-                                  // been set by the user
-// ap messages buffers
-  int apmsg_cqqrz[12];		  // [cq/qrz ?       ?/blank] 
-  int apmsg_call1[12];		  // [mycall ?       ?/blank] 
-  int apmsg_call2[12];		  // [?      hiscall ?/blank] 
-  int apmsg_call1_call2[12];      // [mycall hiscall ?]
-  int apmsg_call1_call2_grid[12]; // [mycall hiscall grid]
-  int apmsg_cq_call2[12];         // [cq     hiscall ?/blank] 
-  int apmsg_cq_call2_grid[12];    // [cq     hiscall grid]
-
-// ap messages masks
-  int apmask_cqqrz[12];		
-  int apmask_cqqrz_ooo[12];	
-  int apmask_call1[12];        
-  int apmask_call1_ooo[12];    
-  int apmask_call2[12];        
-  int apmask_call2_ooo[12];    
-  int apmask_call1_call2[12];  
-  int apmask_call1_call2_grid[12];  
-  int apmask_cq_call2[12];  
-  int apmask_cq_call2_ooo[12];  
-} qra64codec;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-qra64codec *qra64_init(int flags);
-// QRA64 mode initialization function
-// arguments:
-//    flags: set the decoder mode
-//	     QRA_NOAP    use no a-priori information
-//	     QRA_AUTOAP  use any relevant previous decodes
-//	     QRA_USERAP  use a-priori information provided via qra64_apset(...)
-// returns:
-//    Pointer to initialized qra64codec data structure 
-//		this pointer should be passed to the encoding/decoding functions
-//
-//    0   if unsuccessful (can't allocate memory)
-// ----------------------------------------------------------------------------
-
-void qra64_encode(qra64codec *pcodec, int *y, const int *x);
-// QRA64 encoder
-// arguments:
-//    pcodec = pointer to a qra64codec data structure as returned by qra64_init
-//    x      = pointer to the message to be encoded, int x[12]
-//	       x must point to an array of integers (i.e. defined as int x[12])
-//    y      = pointer to encoded message, int y[63]=
-// ----------------------------------------------------------------------------
-
-int  qra64_decode(qra64codec *pcodec, float *ebno, int *x, const float *r);
-// QRA64 mode decoder
-// arguments:
-//    pcodec = pointer to a qra64codec data structure as returned by qra64_init
-//    ebno   = pointer to a float where the avg Eb/No (in dB) will be stored
-//             in case of successfull decoding 
-//             (pass a null pointer if not interested)
-//    x      = pointer to decoded message, int x[12]
-//    r      = pointer to received symbol energies (squared amplitudes)
-//             r must point to an array of length QRA64_M*QRA64_N (=64*63=4032) 
-//	       The first QRA_M entries should be the energies of the first 
-//             symbol in the codeword; the last QRA_M entries should be the 
-//             energies of the last symbol in the codeword
-//
-// return code:
-//
-//  The return code is <0 when decoding is unsuccessful
-//  -16 indicates that the definition of QRA64_NMSG does not match what required by the code
-//  If the decoding process is successfull the return code is accordingly to the following table
-//		rc=0    [?    ?    ?]    AP0	(decoding with no a-priori)
-//		rc=1    [CQ   ?    ?]    AP27
-//		rc=2    [CQ   ?     ]    AP44
-//		rc=3    [CALL ?    ?]    AP29
-//		rc=4    [CALL ?     ]    AP45
-//		rc=5    [CALL CALL ?]    AP57
-//		rc=6    [?    CALL ?]    AP29
-//		rc=7    [?    CALL  ]    AP45
-//		rc=8    [CALL CALL GRID] AP72 (actually a AP68 mask to reduce false decodes)
-//		rc=9    [CQ   CALL ?]    AP55
-//		rc=10   [CQ   CALL  ]    AP70 (actaully a AP68 mask to reduce false decodes)
-
-//  return codes in the range 1-10 indicate the amount and the type of a-priori 
-//  information was required to decode the received message.
-
-
-// Decode a QRA64 msg using a fast-fading metric
-int qra64_decode_fastfading(
-				qra64codec *pcodec,		// ptr to the codec structure
-				float *ebno,			// ptr to where the estimated Eb/No value will be saved
-				int *x,					// ptr to decoded message 
-				const float *rxen,		// ptr to received symbol energies array
-				const int submode,		// submode idx (0=QRA64A ... 4=QRA64E)
-				const float B90,	    // spread bandwidth (90% fractional energy)
-				const int fadingModel); // 0=Gaussian 1=Lorentzian fade model
-//
-// rxen: The array of the received bin energies
-//       Bins must be spaced by integer multiples of the symbol rate (1/Ts Hz)
-//       The array must be an array of total length U = L x N where:
-//			L: is the number of frequency bins per message symbol (see after)
-//          N: is the number of symbols in a QRA64 msg (63)
-//
-//       The number of bins/symbol L depends on the selected submode accordingly to 
-//		 the following rule:
-//			L = (64+64*2^submode+64) = 64*(2+2^submode)
-//		 Tone 0 is always supposed to be at offset 64 in the array.
-//		 The m-th tone nominal frequency is located at offset 64 + m*2^submode (m=0..63)
-//
-//		 Submode A: (2^submode = 1)
-//          L = 64*3 = 196 bins/symbol
-//          Total length of the energies array: U = 192*63 = 12096 floats
-//
-//		 Submode B: (2^submode = 2)
-//          L = 64*4 = 256 bins/symbol
-//          Total length of the energies array: U = 256*63 = 16128 floats
-//
-//		 Submode C: (2^submode = 4)
-//          L = 64*6 = 384 bins/symbol
-//          Total length of the energies array: U = 384*63 = 24192 floats
-//
-//		 Submode D: (2^submode = 8)
-//          L = 64*10 = 640 bins/symbol
-//          Total length of the energies array: U = 640*63 = 40320 floats
-//
-//		 Submode E: (2^submode = 16)
-//          L = 64*18 = 1152 bins/symbol
-//          Total length of the energies array: U = 1152*63 = 72576 floats
-//
-//		Note: The rxen array is modified and reused for internal calculations.
-//
-//
-//	B90: spread fading bandwidth in Hz (90% fractional average energy)
-//
-//			B90 should be in the range 1 Hz ... 238 Hz
-//			The value passed to the call is rounded to the closest value among the 
-//			64 available values:
-//				B = 1.09^k Hz, with k=0,1,...,63
-//
-//			I.e. B90=27 Hz will be approximated in this way:
-//				k = rnd(log(27)/log(1.09)) = 38
-//              B90 = 1.09^k = 1.09^38 = 26.4 Hz
-//
-//          For any input value the maximum rounding error is not larger than +/- 5%
-//          
-// return codes: same return codes of qra64_decode (+some additional error codes)
-
-
-// Simulate the fast-fading channel (to be used with qra64_decode_fastfading)
-int qra64_fastfading_channel(
-				float **rxen, 
-				const int *xmsg, 
-				const int submode,
-				const float EbN0dB, 
-				const float B90, 
-				const int fadingModel);
-// Simulate transmission over a fading channel with given B90, fading model and submode
-// and non coherent detection.
-// Sets rxen to point to an array of bin energies formatted as required 
-// by the (fast-fading) decoding routine.
-// returns 0 on success or negative values on error conditions
-
-
-int qra64_apset(qra64codec *pcodec, const int mycall, const int hiscall, const int grid, const int aptype);
-// Set decoder a-priori knowledge accordingly to the type of the message to 
-// look up for
-// arguments:
-//    pcodec    = pointer to a qra64codec data structure as returned by qra64_init
-//    mycall    = mycall to look for
-//    hiscall   = hiscall to look for
-//    grid      = grid to look for
-//    aptype    = define the type of AP to be set: 
-//		APTYPE_CQQRZ     set [cq/qrz ?       ?/blank]
-//		APTYPE_MYCALL    set [mycall ?       ?/blank]
-//		APTYPE_HISCALL   set [?      hiscall ?/blank]
-//		APTYPE_BOTHCALLS set [mycall hiscall ?]
-//		APTYPE_FULL		 set [mycall hiscall grid]
-//		APTYPE_CQHISCALL set [cq/qrz hiscall ?/blank]
-
-// returns:
-//	 0  on success
-//  -1  when qra64_init was called with the QRA_NOAP flag
-//	-2  invalid apytpe (valid range [APTYPE_CQQRZ..APTYPE_CQHISCALL]
-//	    (APTYPE_CQQRZ [cq/qrz ? ?] is set by default )
-
-void qra64_apdisable(qra64codec *pcodec, const int aptype);
-// disable specific AP type
-// arguments:
-//    pcodec    = pointer to a qra64codec data structure as returned by qra64_init
-//    aptype    = define the type of AP to be disabled
-//		APTYPE_CQQRZ     disable [cq/qrz   ?      ?/blank]
-//		APTYPE_MYCALL    disable [mycall   ?      ?/blank]
-//		APTYPE_HISCALL   disable [   ?   hiscall  ?/blank]
-//		APTYPE_BOTHCALLS disable [mycall hiscall     ?   ]
-//		APTYPE_FULL	 disable [mycall hiscall     grid]
-//		APTYPE_CQHISCALL set [cq/qrz hiscall ?/blank]
-
-void qra64_close(qra64codec *pcodec);
-// Free memory allocated by qra64_init
-// arguments:
-//    pcodec = pointer to a qra64codec data structure as returned by qra64_init
-
-// ----------------------------------------------------------------------------
-
-// encode/decode std msgs in 12 symbols as done in jt65
-void encodemsg_jt65(int *y, const int call1, const int call2, const int grid);
-void decodemsg_jt65(int *call1, int *call2, int *grid, const int *x);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _qra64_h_
diff --git a/lib/qra/qra64/qra64_all.c b/lib/qra/qra64/qra64_all.c
deleted file mode 100644
index 28f8ab928..000000000
--- a/lib/qra/qra64/qra64_all.c
+++ /dev/null
@@ -1,1050 +0,0 @@
-/*
-qra64.c 
-Encoding/decoding functions for the QRA64 mode
-
-(c) 2016 - Nico Palermo, IV3NWV
-
--------------------------------------------------------------------------------
-
-   qracodes 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.
-   qracodes 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 qracodes source distribution.  
-   If not, see <http://www.gnu.org/licenses/>.
-
------------------------------------------------------------------------------
-
-QRA code used in this sowftware release:
-
-QRA13_64_64_IRR_E: K=13 N=64 Q=64 irregular QRA code (defined in 
-qra13_64_64_irr_e.h /.c)
-
-Codes with K=13 are designed to include a CRC as the 13th information symbol
-and improve the code UER (Undetected Error Rate).
-The CRC symbol is not sent along the channel (the codes are punctured) and the 
-resulting code is a (12,63) code 
-*/
-//----------------------------------------------------------------------------
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "qra64.h"
-#include "../qracodes/qracodes.h"
-#include "../qracodes/qra13_64_64_irr_e.h"
-#include "../qracodes/pdmath.h"
-#include "../qracodes/normrnd.h"
-
-// Code parameters of the QRA64 mode 
-#define QRA64_CODE  qra_13_64_64_irr_e
-#define QRA64_NMSG  218        // Must much value indicated in QRA64_CODE.NMSG
-
-#define QRA64_KC (QRA64_K+1)   // Information symbols (crc included)
-#define QRA64_NC (QRA64_N+1)   // Codeword length (as defined in the code)
-#define QRA64_NITER 100	       // max number of iterations per decode
-
-// static functions declarations ----------------------------------------------
-static int  calc_crc6(const int *x, int sz);
-static void ix_mask(float *dst, const float *src, const int *mask, 
-		    const int *x);
-static int qra64_decode_attempts(qra64codec *pcodec, int *xdec, const float *ix);
-static int qra64_do_decode(int *x, const float *pix, const int *ap_mask, 
-			    const int *ap_x);
-static float qra64_fastfading_estim_noise_std(
-				float *rxen, 
-				const float esnometric, 
-				const int submode);
-static void qra64_fastfading_intrinsics(
-				float *pix, 
-				const float *rxamp, 
-				const float *hptr, 
-				const int    hlen, 
-				const float cmetric, 
-				const int submode);
-static float qra64_fastfading_msg_esno(
-			const int *ydec,
-			const float *rxamp, 
-			const float sigma,
-			const float EsNoMetric,
-			const int hlen, 
-			const int submode);
-
-
-// a-priori information masks for fields in JT65-like msgs --------------------
-#define MASK_CQQRZ      0xFFFFFFC // CQ/QRZ calls common bits
-#define MASK_CALL1      0xFFFFFFF
-#define MASK_CALL2      0xFFFFFFF
-#define MASK_GRIDFULL	0xFFFF
-#define MASK_GRIDFULL12	0x3FFC	  // less aggressive mask (to be used with full AP decoding)
-#define MASK_GRIDBIT	0x8000	  // b[15] is 1 for free text, 0 otherwise
-// ----------------------------------------------------------------------------
-
-qra64codec *qra64_init(int flags)
-{
-
-  // Eb/No value for which we optimize the decoder metric
-  const float EbNodBMetric = 2.8f; 
-  const float EbNoMetric   = (float)pow(10,EbNodBMetric/10);
-  const float R = 1.0f*(QRA64_KC)/(QRA64_NC);	
-
-  qra64codec *pcodec = (qra64codec*)malloc(sizeof(qra64codec));
-
-  if (!pcodec)
-    return 0;	// can't allocate memory
-
-  pcodec->decEsNoMetric   = 1.0f*QRA64_m*R*EbNoMetric;
-  pcodec->apflags			= flags;
-
-  memset(pcodec->apmsg_set,0,APTYPE_SIZE*sizeof(int));
-
-  if (flags==QRA_NOAP)
-    return pcodec;
-
-  // for QRA_USERAP and QRA_AUTOAP modes we always enable [CQ/QRZ ? ?] mgs look-up.
-  // encode CQ/QRZ AP messages 
-  // NOTE: Here we handle only CQ and QRZ msgs. 
-  // 'CQ nnn', 'CQ DX' and 'DE' msgs will be handled by the decoder 
-  // as messages with no a-priori knowledge
-  qra64_apset(pcodec, CALL_CQ, 0, GRID_BLANK, APTYPE_CQQRZ);
-
-  // initialize masks for decoding with a-priori information
-  encodemsg_jt65(pcodec->apmask_cqqrz,     MASK_CQQRZ, 0, MASK_GRIDBIT);     
-  encodemsg_jt65(pcodec->apmask_cqqrz_ooo, MASK_CQQRZ, 0, MASK_GRIDFULL);
-  encodemsg_jt65(pcodec->apmask_call1,     MASK_CALL1, 0, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_call1_ooo, MASK_CALL1, 0, MASK_GRIDFULL);
-  encodemsg_jt65(pcodec->apmask_call2,     0, MASK_CALL2, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_call2_ooo, 0, MASK_CALL2, MASK_GRIDFULL);
-  encodemsg_jt65(pcodec->apmask_call1_call2,     MASK_CALL1,MASK_CALL2, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_call1_call2_grid,MASK_CALL1,MASK_CALL2, MASK_GRIDFULL12);
-  encodemsg_jt65(pcodec->apmask_cq_call2,     MASK_CQQRZ, MASK_CALL2, MASK_GRIDBIT);
-  encodemsg_jt65(pcodec->apmask_cq_call2_ooo, MASK_CQQRZ, MASK_CALL2, MASK_GRIDFULL12);
-
-  return pcodec;
-}
-
-void qra64_close(qra64codec *pcodec)
-{
-	free(pcodec);
-}
-
-int qra64_apset(qra64codec *pcodec, const int mycall, const int hiscall, const int grid, const int aptype)
-{
-// Set decoder a-priori knowledge accordingly to the type of the message to look up for
-// arguments:
-//		pcodec    = pointer to a qra64codec data structure as returned by qra64_init
-//		mycall    = mycall to look for
-//		hiscall   = hiscall to look for
-//		grid      = grid to look for
-//		aptype    = define and masks the type of AP to be set accordingly to the following:
-//			APTYPE_CQQRZ     set [cq/qrz ?       ?/blank]
-//			APTYPE_MYCALL    set [mycall ?       ?/blank]
-//			APTYPE_HISCALL   set [?      hiscall ?/blank]
-//			APTYPE_BOTHCALLS set [mycall hiscall ?]
-//			APTYPE_FULL		 set [mycall hiscall grid]
-//			APTYPE_CQHISCALL set [cq/qrz hiscall ?/blank] and [cq/qrz hiscall grid]
-// returns:
-//		0   on success
-//      -1  when qra64_init was called with the QRA_NOAP flag
-//		-2  invalid apytpe
-
-	if (pcodec->apflags==QRA_NOAP)
-		return -1;
-
-	switch (aptype) {
-		case APTYPE_CQQRZ:
-			encodemsg_jt65(pcodec->apmsg_cqqrz,  CALL_CQ, 0, GRID_BLANK);
-			break;
-		case APTYPE_MYCALL:
-			encodemsg_jt65(pcodec->apmsg_call1,  mycall,  0, GRID_BLANK);
-			break;
-		case APTYPE_HISCALL:
-			encodemsg_jt65(pcodec->apmsg_call2,  0, hiscall, GRID_BLANK);
-			break;
-		case APTYPE_BOTHCALLS:
-			encodemsg_jt65(pcodec->apmsg_call1_call2,  mycall, hiscall, GRID_BLANK);
-			break;
-		case APTYPE_FULL:
-			encodemsg_jt65(pcodec->apmsg_call1_call2_grid,  mycall, hiscall, grid);
-			break;
-		case APTYPE_CQHISCALL:
-			encodemsg_jt65(pcodec->apmsg_cq_call2,      CALL_CQ, hiscall, GRID_BLANK);
-			encodemsg_jt65(pcodec->apmsg_cq_call2_grid, CALL_CQ, hiscall, grid);
-			break;
-		default:
-			return -2;	// invalid ap type
-		}
-
-	  pcodec->apmsg_set[aptype]=1;	// signal the decoder to look-up for the specified type
-
-
-	  return 0;
-}
-void qra64_apdisable(qra64codec *pcodec, const int aptype)
-{
-	if (pcodec->apflags==QRA_NOAP)
-		return;
-
-	if (aptype<APTYPE_CQQRZ || aptype>=APTYPE_SIZE)
-		return;
-
-	pcodec->apmsg_set[aptype] = 0;	//  signal the decoder not to look-up to the specified type
-}
-
-void qra64_encode(qra64codec *pcodec, int *y, const int *x)
-{
-  int encx[QRA64_KC];	// encoder input buffer
-  int ency[QRA64_NC];	// encoder output buffer
-
-  int hiscall,mycall,grid;
-
-  memcpy(encx,x,QRA64_K*sizeof(int));		// Copy input to encoder buffer
-  encx[QRA64_K]=calc_crc6(encx,QRA64_K);	// Compute and add crc symbol
-  qra_encode(&QRA64_CODE, ency, encx);	 // encode msg+crc using given QRA code
-
-  // copy codeword to output puncturing the crc symbol 
-  memcpy(y,ency,QRA64_K*sizeof(int));		// copy information symbols 
-  memcpy(y+QRA64_K,ency+QRA64_KC,QRA64_C*sizeof(int)); // copy parity symbols 
-
-  if (pcodec->apflags!=QRA_AUTOAP)
-    return;
-
-  // Here we handle the QRA_AUTOAP mode --------------------------------------------
-
-  // When a [hiscall mycall ?] msg is detected we instruct the decoder
-  // to look for [mycall hiscall ?] msgs
-  // otherwise when a [cq mycall ?] msg is sent we reset the APTYPE_BOTHCALLS 
-
-  // look if the msg sent is a std type message (bit15 of grid field = 0)
-  if ((x[9]&0x80)==1)
-    return;	// no, it's a text message, nothing to do
-
-  // It's a [hiscall mycall grid] message
-
-  // We assume that mycall is our call (but we don't check it)
-  // hiscall the station we are calling or a general call (CQ/QRZ/etc..)
-  decodemsg_jt65(&hiscall,&mycall,&grid,x);
-
-
-  if ((hiscall>=CALL_CQ && hiscall<=CALL_CQ999) || hiscall==CALL_CQDX || 
-      hiscall==CALL_DE) {
-	// tell the decoder to look for msgs directed to us
-	qra64_apset(pcodec,mycall,0,0,APTYPE_MYCALL);
-    // We are making a general call and don't know who might reply 
-    // Reset APTYPE_BOTHCALLS so decoder won't look for [mycall hiscall ?] msgs
-    qra64_apdisable(pcodec,APTYPE_BOTHCALLS);
-  } else {
-    // We are replying to someone named hiscall
-    // Set APTYPE_BOTHCALLS so decoder will try for [mycall hiscall ?] msgs
-    qra64_apset(pcodec,mycall, hiscall, GRID_BLANK, APTYPE_BOTHCALLS);
-  }
-
-}
-
-#define EBNO_MIN -10.0f		// minimum Eb/No value returned by the decoder (in dB)
-int qra64_decode(qra64codec *pcodec, float *ebno, int *x, const float *rxen)
-{
-  int k;
-  float *srctmp, *dsttmp;
-  float ix[QRA64_NC*QRA64_M];		// (depunctured) intrisic information
-  int   xdec[QRA64_KC];				// decoded message (with crc)
-  int   ydec[QRA64_NC];				// re-encoded message (for snr calculations)
-  float noisestd;					// estimated noise variance
-  float msge;						// estimated message energy
-  float ebnoval;					// estimated Eb/No
-  int rc;
-  
-  if (QRA64_NMSG!=QRA64_CODE.NMSG)      // sanity check 
-    return -16;				// QRA64_NMSG define is wrong
-
-  // compute symbols intrinsic probabilities from received energy observations
-  noisestd = qra_mfskbesselmetric(ix, rxen, QRA64_m, QRA64_N,pcodec->decEsNoMetric);
-
-  // de-puncture observations adding a uniform distribution for the crc symbol
-
-  // move check symbols distributions one symbol towards the end
-  dsttmp = PD_ROWADDR(ix,QRA64_M, QRA64_NC-1);	//Point to last symbol prob dist
-  srctmp = dsttmp-QRA64_M;              // source is the previous pd
-  for (k=0;k<QRA64_C;k++) {
-    pd_init(dsttmp,srctmp,QRA64_M);
-    dsttmp -=QRA64_M;
-    srctmp -=QRA64_M;
-  }
-  // Initialize crc prob to a uniform distribution
-  pd_init(dsttmp,pd_uniform(QRA64_m),QRA64_M);
-
-  // Try to decode using all AP cases if required
-  rc = qra64_decode_attempts(pcodec, xdec, ix);
-
-  if (rc<0)
-	  return rc;	// no success
-
-  // successfull decode --------------------------------
-  
-  // copy decoded message (without crc) to output buffer
-  memcpy(x,xdec,QRA64_K*sizeof(int));
-
-  if (ebno==0)	// null pointer indicates we are not interested in the Eb/No estimate
-	  return rc;
-
-  // reencode message and estimate Eb/No
-  qra_encode(&QRA64_CODE, ydec, xdec);	 
-  // puncture crc
-  memmove(ydec+QRA64_K,ydec+QRA64_KC,QRA64_C*sizeof(int)); 
-  // compute total power of decoded message
-  msge = 0;
-  for (k=0;k<QRA64_N;k++) {
-	  msge +=rxen[ydec[k]];	// add energy of current symbol
-	  rxen+=QRA64_M;			// ptr to next symbol
-	  }
-
-  // NOTE:
-  // To make a more accurate Eb/No estimation we should compute the noise variance
-  // on all the rxen values but the transmitted symbols.
-  // Noisestd is compute by qra_mfskbesselmetric assuming that
-  // the signal power is much less than the total noise power in the QRA64_M tones
-  // but this is true only if the Eb/No is low.
-  // Here, in order to improve accuracy, we linearize the estimated Eb/No value empirically
-  // (it gets compressed when it is very high as in this case the noise variance 
-  // is overestimated)
-
-  // this would be the exact value if the noisestd were not overestimated at high Eb/No
-  ebnoval = (0.5f/(QRA64_K*QRA64_m))*msge/(noisestd*noisestd)-1.0f; 
-
-  // Empirical linearization (to remove the noise variance overestimation)
-  // the resulting SNR is accurate up to +20 dB (51 dB Eb/No)
-  if (ebnoval>57.004f)
-	  ebnoval=57.004f;
-  ebnoval = ebnoval*57.03f/(57.03f-ebnoval);
-
-  // compute value in dB
-  if (ebnoval<=0)
-	  ebnoval = EBNO_MIN; // assume a minimum, positive value
-  else
-	  ebnoval = 10.0f*(float)log10(ebnoval);
-	  if (ebnoval<EBNO_MIN)
-		  ebnoval = EBNO_MIN;
-  
-  *ebno = ebnoval;
-
-  return rc;	
-}
-
-// Tables of fading amplitudes coefficients for QRA64 (Ts=6912/12000)
-// As the fading is assumed to be symmetric around the nominal frequency
-// only the leftmost and the central coefficient are stored in the tables.
-// (files have been generated with the Matlab code efgengauss.m and efgenlorentz.m)
-#include "fadampgauss.c"
-#include "fadamplorentz.c"
-
-int qra64_decode_fastfading(
-				qra64codec *pcodec,		// ptr to the codec structure
-				float *ebno,			// ptr to where the estimated Eb/No value will be saved
-				int *x,					// ptr to decoded message 
-				float *rxen,		    // ptr to received symbol energies array
-				const int submode,		// submode idx (0=QRA64A ... 4=QRA64E)
-				const float B90,	    // spread bandwidth (90% fractional energy)
-				const int fadingModel)  // 0=Gaussian 1=Lorentzian fade model
-
-// Decode a QRA64 msg using a fast-fading metric
-//
-// rxen: The array of the received bin energies
-//       Bins must be spaced by integer multiples of the symbol rate (1/Ts Hz)
-//       The array must be an array of total length U = L x N where:
-//			L: is the number of frequency bins per message symbol (see after)
-//          N: is the number of symbols in a QRA64 msg (63)
-
-//       The number of bins/symbol L depends on the selected submode accordingly to 
-//		 the following rule:
-//			L = (64+64*2^submode+64) = 64*(2+2^submode)
-//		 Tone 0 is always supposed to be at offset 64 in the array.
-//		 The m-th tone nominal frequency is located at offset 64 + m*2^submode (m=0..63)
-//
-//		 Submode A: (2^submode = 1)
-//          L = 64*3 = 196 bins/symbol
-//          Total length of the energies array: U = 192*63 = 12096 floats
-//
-//		 Submode B: (2^submode = 2)
-//          L = 64*4 = 256 bins/symbol
-//          Total length of the energies array: U = 256*63 = 16128 floats
-//
-//		 Submode C: (2^submode = 4)
-//          L = 64*6 = 384 bins/symbol
-//          Total length of the energies array: U = 384*63 = 24192 floats
-//
-//		 Submode D: (2^submode = 8)
-//          L = 64*10 = 640 bins/symbol
-//          Total length of the energies array: U = 640*63 = 40320 floats
-//
-//		 Submode E: (2^submode = 16)
-//          L = 64*18 = 1152 bins/symbol
-//          Total length of the energies array: U = 1152*63 = 72576 floats
-//
-//		Note: The rxen array is modified and reused for internal calculations.
-//
-//
-//	B90: spread fading bandwidth in Hz (90% fractional average energy)
-//
-//			B90 should be in the range 1 Hz ... 238 Hz
-//			The value passed to the call is rounded to the closest value among the 
-//			64 available values:
-//				B = 1.09^k Hz, with k=0,1,...,63
-//
-//			I.e. B90=27 Hz will be approximated in this way:
-//				k = rnd(log(27)/log(1.09)) = 38
-//              B90 = 1.09^k = 1.09^38 = 26.4 Hz
-//
-//          For any input value the maximum rounding error is not larger than +/- 5%
-//          
-
-{
-
-  int k;
-  float *srctmp, *dsttmp;
-  float ix[QRA64_NC*QRA64_M];		// (depunctured) intrisic information
-  int   xdec[QRA64_KC];				// decoded message (with crc)
-  int   ydec[QRA64_NC];				// re-encoded message (for snr calculations)
-  float noisestd;					// estimated noise std
-  float esno,ebnoval;				// estimated Eb/No
-  float tempf;
-  float EsNoMetric, cmetric;
-  int rc;
-  int hidx, hlen;
-  const float *hptr;
-  
-	if (QRA64_NMSG!=QRA64_CODE.NMSG)
-		return -16;					// QRA64_NMSG define is wrong
-
-	if (submode<0 || submode>4)
-		return -17;				// invalid submode
-
-	if (B90<1.0f || B90>238.0f)	
-		return -18;				// B90 out of range
-
-	// compute index to most appropriate amplitude weighting function coefficients
-    hidx = (int)(log((float)B90)/log(1.09f) - 0.499f);
-
-	if (hidx<0 || hidx > 64) 
-		return -19;				// index of weighting function out of range
-
-	if (fadingModel==0) {	 // gaussian fading model
-		// point to gaussian weighting taps
-		hlen = hlen_tab_gauss[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = hptr_tab_gauss[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else if (fadingModel==1) {
-		// point to lorentzian weighting taps
-		hlen = hlen_tab_lorentz[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = hptr_tab_lorentz[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else 
-		return -20;			// invalid fading model index
-
-
-	// compute (euristically) the optimal decoder metric accordingly the given spread amount
-	// We assume that the decoder threshold is:
-	//		Es/No(dB) = Es/No(AWGN)(dB) + 8*log(B90)/log(240)(dB)
-	// that's to say, at the maximum Doppler spread bandwidth (240 Hz) there's a ~8 dB Es/No degradation
-	// over the AWGN case
-	tempf = 8.0f*(float)log((float)B90)/(float)log(240.0f);
-	EsNoMetric = pcodec->decEsNoMetric*(float)pow(10.0f,tempf/10.0f);
-
-	// Step 1 ----------------------------------------------------------------------------------- 
-	// Evaluate the noise stdev from the received energies at nominal tone frequencies
-    // and transform energies to amplitudes
-	tempf = hptr[hlen-1];				// amplitude weigth at nominal freq;
-	tempf = tempf*tempf;				// fractional energy at nominal freq. bin
-	
-	noisestd = qra64_fastfading_estim_noise_std(rxen, EsNoMetric, submode);
-	cmetric = (float)sqrt(M_PI_2*EsNoMetric)/noisestd;
-
-	// Step 2 -----------------------------------------------------------------------------------
-	// Compute message symbols probability distributions
-	qra64_fastfading_intrinsics(ix, rxen, hptr, hlen, cmetric, submode);
-
-	// Step 3 ---------------------------------------------------------------------------
-	// De-puncture observations adding a uniform distribution for the crc symbol
-	// Move check symbols distributions one symbol towards the end
-	dsttmp = PD_ROWADDR(ix,QRA64_M, QRA64_NC-1);	//Point to last symbol prob dist
-	srctmp = dsttmp-QRA64_M;              // source is the previous pd
-	for (k=0;k<QRA64_C;k++) {
-		pd_init(dsttmp,srctmp,QRA64_M);
-		dsttmp -=QRA64_M;
-		srctmp -=QRA64_M;
-		}
-	// Initialize crc prob to a uniform distribution
-	pd_init(dsttmp,pd_uniform(QRA64_m),QRA64_M);
-
-	// Step 4 ---------------------------------------------------------------------------
-	// Attempt to decode
-	rc = qra64_decode_attempts(pcodec, xdec, ix);
-	if (rc<0)
-	  return rc;	// no success
-
-	// copy decoded message (without crc) to output buffer
-	memcpy(x,xdec,QRA64_K*sizeof(int));
-
-	// Step 5 ----------------------------------------------------------------------------
-	// Estimate the message Eb/No
-
-	if (ebno==0)	// null pointer indicates we are not interested in the Eb/No estimate
-		return rc;
-
-	// reencode message to estimate Eb/No
-	qra_encode(&QRA64_CODE, ydec, xdec);	 
-	// puncture crc
-	memmove(ydec+QRA64_K,ydec+QRA64_KC,QRA64_C*sizeof(int)); 
-
-	// compute Es/N0 of decoded message
-	esno = qra64_fastfading_msg_esno(ydec,rxen,noisestd, EsNoMetric, hlen,submode);
-
-	// as the weigthing function include about 90% of the energy
-	// we could compute the unbiased esno with:
-	// esno = esno/0.9;
-	
-	// this would be the exact value if the noisestd were not overestimated at high Eb/No
-	ebnoval = 1.0f/(1.0f*QRA64_K/QRA64_N*QRA64_m)*esno; 
-
-	// compute value in dB
-	if (ebnoval<=0)
-	  ebnoval = EBNO_MIN; // assume a minimum, positive value
-	else
-	  ebnoval = 10.0f*(float)log10(ebnoval);
-	  if (ebnoval<EBNO_MIN)
-		  ebnoval = EBNO_MIN;
-  
-	*ebno = ebnoval;
-
-  return rc;	
-
-}
-
-
-
-int qra64_fastfading_channel(float **rxen, const int *xmsg, const int submode, const float EbN0dB, const float B90, const int fadingModel)
-{
-	// Simulate transmission over a fading channel and non coherent detection
-
-	// Set rxen to point to an array of bin energies formatted as required 
-	// by the (fast-fading) decoding routine
-
-	// returns 0 on success or negative values on error conditions
-
-	static float *channel_out = NULL;
-	static int    channel_submode = -1;
-
-	int bpt = (1<<submode);			// bins per tone 
-	int bps = QRA64_M*(2+bpt);		// total number of bins per symbols
-	int bpm = bps*QRA64_N;			// total number of bins in a message
-	int n,j,hidx, hlen;
-	const float *hptr;
-	float *cursym,*curtone;
-
-	float iq[2];
-	float *curi, *curq;
-
-//	float tote=0;	// debug
-
-	float N0, EsN0, Es, A, sigmanoise, sigmasig;
-
-	if (rxen==NULL)
-		return -1;		// rxen must be a non-null ptr 
-
-	// allocate output buffer if not yet done or if submode changed
-	if (channel_out==NULL || submode!=channel_submode) {
-
-		// unallocate previous buffer
-		if (channel_out)
-			free(channel_out);
-
-		// allocate new buffer
-		// we allocate twice the mem so that we can store/compute complex amplitudes
-		channel_out = (float*)malloc(bpm*sizeof(float)*2);	
-		if (channel_out==NULL)
-			return -2;	// error allocating memory
-
-		channel_submode = submode;
-		}
-
-	if (B90<1.0f || B90>238.0f)	
-		return -18;				// B90 out of range
-
-	// compute index to most appropriate amplitude weighting function coefficients
-    hidx = (int)(log((float)B90)/log(1.09f) - 0.499f);
-
-	if (hidx<0 || hidx > 64) 
-		return -19;				// index of weighting function out of range
-
-	if (fadingModel==0) {	 // gaussian fading model
-		// point to gaussian weighting taps
-		hlen = hlen_tab_gauss[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = hptr_tab_gauss[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else if (fadingModel==1) {
-		// point to lorentzian weighting taps
-		hlen = hlen_tab_lorentz[hidx];	 // hlen = (L+1)/2 (where L=(odd) number of taps of w fun)
-		hptr = hptr_tab_lorentz[hidx];     // pointer to the first (L+1)/2 coefficients of w fun
-		}
-	else 
-		return -20;			// invalid fading model index
-
-
-	// Compute the unfaded tone amplitudes from the Eb/No value passed to the call
-	N0 = 1.0f;	// assume unitary noise PSD
-	sigmanoise = (float)sqrt(N0/2);
-	EsN0 = (float)pow(10.0f,EbN0dB/10.0f)*QRA64_m*QRA64_K/QRA64_N; // Es/No = m*R*Eb/No
-	Es   = EsN0*N0;
-	A    = (float)sqrt(Es/2.0f);	// unfaded tone amplitude (i^2+q^2 = Es/2+Es/2 = Es)
-
-
-	// Generate gaussian noise iq components
-	normrnd_s(channel_out, bpm*2, 0 , sigmanoise);
-
-	// Add message symbols energies
-	for (n=0;n<QRA64_N;n++) {					
-
-		cursym  = channel_out+n*bps + QRA64_M; // point to n-th symbol
-		curtone = cursym+xmsg[n]*bpt;	 // point to encoded tone 
-		curi    = curtone-hlen+1;		 // point to real part of first bin
-		curq    = curtone-hlen+1+bpm;	 // point to imag part of first bin
-		
-		// generate Rayleigh faded bins with given average energy and add to noise
-		for (j=0;j<hlen;j++) {	
-			sigmasig = A*hptr[j];
-			normrnd_s(iq, 2, 0 , sigmasig);
-//			iq[0]=sigmasig*sqrt(2); iq[1]=0;	debug: used to verify Eb/No 
-			*curi++ += iq[0];
-			*curq++ += iq[1];
-//			tote +=iq[0]*iq[0]+iq[1]*iq[1];		// debug
-			}
-		for (j=hlen-2;j>=0;j--) {	
-			sigmasig = A*hptr[j];
-			normrnd_s(iq, 2, 0 , sigmasig);
-//			iq[0]=sigmasig*sqrt(2); iq[1]=0;	debug: used to verify Eb/No
-			*curi++ += iq[0];
-			*curq++ += iq[1];
-//			tote +=iq[0]*iq[0]+iq[1]*iq[1];		// debug
-			}
-
-		}
-
-//	tote = tote/QRA64_N;	// debug
-
-	// compute total bin energies (S+N) and store in first half of buffer
-	curi = channel_out;
-	curq = channel_out+bpm;
-	for (n=0;n<bpm;n++) 					
-		channel_out[n] = curi[n]*curi[n] + curq[n]*curq[n];
-
-	// set rxen to point to the channel output energies
-	*rxen = channel_out;
-
-	return 0;	
-}
-
-
-
-// Static functions definitions ----------------------------------------------
-
-// fast-fading static functions --------------------------------------------------------------
-
-static float qra64_fastfading_estim_noise_std(float *rxen, const float esnometric, const int submode)
-{
-	// estimate the noise standard deviation from nominal frequency symbol bins
-	// transform energies to amplitudes
-
-	// rxen = message symbols energies (overwritten with symbols amplitudes)
-	// esnometric = Es/No at nominal frequency bin for which we compute the decoder metric
-	// submode = submode used (0=A...4=E)
-
-	int bpt = (1<<submode);			// bins per tone 
-	int bps = QRA64_M*(2+bpt);		// total number of bins per symbols
-	int bpm = bps*QRA64_N;			// total number of bins in a message
-	int k;
-	float sigmaest;
-
-	// estimate noise std
-	sigmaest = 0;
-	for (k=0;k<bpm;k++) {
-		sigmaest += rxen[k];
-		// convert energies to amplitudes for later use
-		rxen[k] = (float)sqrt(rxen[k]);	// we do it in place to avoid memory allocations
-		}
-	sigmaest = sigmaest/bpm;
-	sigmaest = (float)sqrt(sigmaest/(1.0f+esnometric/bps)/2.0f); 
-
-	// Note: sigma is overestimated by the (unknown) factor sqrt((1+esno(true)/bps)/(1+esnometric/bps))
-
-	return sigmaest;
-}
-
-static void qra64_fastfading_intrinsics(
-				float *pix, 
-				const float *rxamp, 
-				const float *hptr, 
-				const int    hlen, 
-				const float cmetric, 
-				const int submode)
-{
-
-	// For each symbol in a message:
-	// a) Compute tones loglikelihoods as a sum of products between of the expected 
-	// amplitude fading coefficient and received amplitudes.
-	// Each product is computed as log(I0(hk*xk*cmetric)) where hk is the average fading amplitude,
-	// xk is the received amplitude at bin offset k, and cmetric is a constant dependend on the
-	// Eb/N0 value for which the metric is optimized
-	// The function y = log(I0(x)) is approximated as y = x^2/(x+e)
-	// b) Compute intrinsic symbols probability distributions from symbols loglikelihoods
-
-	int n,k,j, bps, bpt;
-	const float *cursym, *curbin;
-	float *curix;
-	float u, maxloglh, loglh, sumix;
-
-	bpt = 1<<submode;				// bins per tone
-	bps = QRA64_M*(2+bpt);			// bins per symbol
-
-	for (n=0;n<QRA64_N;n++) {			// for each symbol in the message
-		cursym = rxamp+n*bps + QRA64_M;	// point to current symbol nominal bin
-		maxloglh = 0;
-		curix  = pix+n*QRA64_M;		
-		for (k=0;k<QRA64_M;k++) {   // for each tone in the current symbol
-			curbin = cursym + k*bpt -hlen+1;	// ptr to lowest bin of the current tone
-			// compute tone loglikelihood as a weighted sum of bins loglikelihoods
-			loglh = 0.f;
-			for (j=0;j<hlen;j++) {	
-				u = *curbin++ * hptr[j]*cmetric;
-				u = u*u/(u+(float)M_E);	// log(I0(u)) approx.
-				loglh = loglh + u;	
-				}
-			for (j=hlen-2;j>=0;j--) {	
-				u = *curbin++ * hptr[j]*cmetric;
-				u = u*u/(u+(float)M_E);	// log(I0(u)) approx.
-				loglh = loglh + u;
-				}
-			if (loglh>maxloglh)		// keep track of the max loglikelihood
-				maxloglh = loglh;
-			curix[k]=loglh;
-			}
-		// scale to likelihoods
-		sumix = 0.f;
-		for (k=0;k<QRA64_M;k++) {   
-			u = (float)exp(curix[k]-maxloglh);
-			curix[k]=u;
-			sumix +=u;
-			}
-		// scale to probabilities
-		sumix = 1.0f/sumix;
-		for (k=0;k<QRA64_M;k++) 
-			curix[k] = curix[k]*sumix;
-		}
-}
-
-static float qra64_fastfading_msg_esno(
-			const int *ydec,
-			const float *rxamp, 
-			const float sigma,
-			const float EsNoMetric,
-			const int hlen, 
-			const int submode)
-{
-	// Estimate msg Es/N0
-
-	int n,j, bps, bpt;
-	const float *cursym, *curtone, *curbin;
-	float u, msgsn,esno;
-	int tothlen = 2*hlen-1;
-
-	bpt = 1<<submode;				// bins per tone
-	bps = QRA64_M*(2+bpt);			// bins per symbol
-
-	msgsn = 0;
-	for (n=0;n<QRA64_N;n++) {					
-		cursym  = rxamp+n*bps + QRA64_M; // point to n-th symbol amplitudes
-		curtone = cursym+ydec[n]*bpt;	 // point to decoded tone amplitudes
-		curbin  = curtone-hlen+1;		 // point to first bin amplitude
-		
-		// sum bin energies
-		for (j=0;j<hlen;j++) {	
-			u = *curbin++; 
-			msgsn += u*u;	
-			}
-		for (j=hlen-2;j>=0;j--) {	
-			u = *curbin++; 
-			msgsn += u*u;	
-			}
-
-		}
-
-	msgsn =  msgsn/(QRA64_N*tothlen);	// avg msg energy per bin (noise included)
-
-	// as sigma is overestimated (sigmatrue = sigma*sqrt((1+EsNoMetric/bps)/(1+EsNo/bps))
-	// we have: msgsn = (1+x/hlen)/(1+x/bps)*2*sigma^2*(1+EsnoMetric/bps), where x = Es/N0(true)
-	//
-	// we can then write:
-	// u = msgsn/2.0f/(sigma*sigma)/(1.0f+EsNoMetric/bps);
-	// (1+x/hlen)/(1+x/bps) = u
-
-	u = msgsn/(2.0f*sigma*sigma)/(1.0f+EsNoMetric/bps);
-
-	// check u>1 
-	if (u<1)
-		return 0.f;
-
-	// check u<bps/tot hlen
-	if (u>(bps/tothlen))
-		return 10000.f;
-
-	// solve for Es/No
-	esno = (u-1.0f)/(1.0f/tothlen-u/bps);
-
-	return esno;
-	
-
-}
-
-
-// Attempt to decode given intrisic information
-static int qra64_decode_attempts(qra64codec *pcodec, int *xdec, const float *ix)
-{
-  int rc;
-
-  // Attempt to decode without a-priori info --------------------------------
-  rc = qra64_do_decode(xdec, ix, NULL, NULL);
-  if (rc>=0) 
-	  return 0; // successfull decode with AP0
-  else
-	  if (pcodec->apflags==QRA_NOAP) 
-		  // nothing more to do
-		  return rc; // rc<0 = unsuccessful decode
-
-  // Here we handle decoding with AP knowledge
-
-  // Attempt to decode CQ calls
-  rc = qra64_do_decode(xdec,ix,pcodec->apmask_cqqrz, pcodec->apmsg_cqqrz); 
-  if (rc>=0) return 1;    // decoded [cq/qrz ? ?]
-
-  rc = qra64_do_decode(xdec, ix, pcodec->apmask_cqqrz_ooo, 
-		       pcodec->apmsg_cqqrz);	                        
-  if (rc>=0) return 2;    // decoded [cq ? ooo]
-
-  // attempt to decode calls directed to us 
-  if (pcodec->apmsg_set[APTYPE_MYCALL]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1, 
-		       pcodec->apmsg_call1);		                
-	if (rc>=0) return 3;    // decoded [mycall ? ?]
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1_ooo, 
-		       pcodec->apmsg_call1);	                    
-	if (rc>=0) return 4;    // decoded [mycall ? ooo]
-	}
-
-  // attempt to decode [mycall srccall ?] msgs
-  if (pcodec->apmsg_set[APTYPE_BOTHCALLS]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1_call2, 
-		       pcodec->apmsg_call1_call2);	                
-	if (rc>=0) return 5;    // decoded [mycall srccall ?]	
-	}
-
-  // attempt to decode [? hiscall ?/b] msgs
-  if (pcodec->apmsg_set[APTYPE_HISCALL]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call2, 
-		       pcodec->apmsg_call2);		                
-	if (rc>=0) return 6;    // decoded [? hiscall ?]
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call2_ooo, 
-		       pcodec->apmsg_call2);	                    
-	if (rc>=0) return 7;    // decoded [? hiscall ooo]
-	}
-
-  // attempt to decode [cq/qrz hiscall ?/b/grid] msgs
-  if (pcodec->apmsg_set[APTYPE_CQHISCALL]) {
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_cq_call2, 
-				pcodec->apmsg_cq_call2);		                
-	if (rc>=0) return 9;	// decoded [cq/qrz hiscall ?]
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_cq_call2_ooo, 
-		       pcodec->apmsg_cq_call2_grid);	
-	if (rc>=0) {
-		// Full AP mask need special handling
-		// To minimize false decodes we check the decoded message
-		// with what passed in the ap_set call
-		if (memcmp(pcodec->apmsg_cq_call2_grid,xdec, QRA64_K*sizeof(int))!=0) 
-			return -1;
-		else
-			return 11;		// decoded [cq/qrz hiscall grid]
-		};    
-
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_cq_call2_ooo, 
-		       pcodec->apmsg_cq_call2);	                    
-	if (rc>=0) { 
-		// Full AP mask need special handling
-		// To minimize false decodes we check the decoded message
-		// with what passed in the ap_set call
-		if (memcmp(pcodec->apmsg_cq_call2,xdec, QRA64_K*sizeof(int))!=0) 
-			return -1;
-		else
-			return 10;    // decoded [cq/qrz hiscall ]
-		}
-	}
-
-  // attempt to decode [mycall hiscall grid]
-  if (pcodec->apmsg_set[APTYPE_FULL]) {
-	rc = qra64_do_decode(xdec, ix, pcodec->apmask_call1_call2_grid, 
-		       pcodec->apmsg_call1_call2_grid); 
-	if (rc>=0) { 
-		// Full AP mask need special handling
-		// All the three msg fields were given.
-		// To minimize false decodes we check the decoded message
-		// with what passed in the ap_set call
-		if (memcmp(pcodec->apmsg_call1_call2_grid,xdec, QRA64_K*sizeof(int))!=0) 
-			return -1;
-		else
-			return 8;	   // decoded [mycall hiscall grid]
-		}
-	}
-
-  // all decoding attempts failed
-  return rc;
-}
-
-
-
-// Decode with given a-priori information 
-static int qra64_do_decode(int *xdec, const float *pix, const int *ap_mask, 
-			   const int *ap_x)
-{
-  int rc;
-  const float *ixsrc;
-  float ix_masked[QRA64_NC*QRA64_M];  // Masked intrinsic information
-  float ex[QRA64_NC*QRA64_M];	      // Extrinsic information from the decoder
-
-  float v2cmsg[QRA64_NMSG*QRA64_M];   // buffers for the decoder messages
-  float c2vmsg[QRA64_NMSG*QRA64_M];
-
-  if (ap_mask==NULL) {   // no a-priori information
-    ixsrc = pix;	 // intrinsic source is what passed as argument
-  } else {	
-    // a-priori information provided
-    // mask channel observations with a-priori 
-    ix_mask(ix_masked,pix,ap_mask,ap_x);
-    ixsrc = ix_masked;	// intrinsic source is the masked version
-  }
-
-  // run the decoding algorithm
-  rc = qra_extrinsic(&QRA64_CODE,ex,ixsrc,QRA64_NITER,v2cmsg,c2vmsg);
-  if (rc<0)
-    return -1;	// no convergence in given iterations
-
-  // decode 
-  qra_mapdecode(&QRA64_CODE,xdec,ex,ixsrc);
-
-  // verify crc
-  if (calc_crc6(xdec,QRA64_K)!=xdec[QRA64_K]) // crc doesn't match (detected error)
-    return -2;	// decoding was succesfull but crc doesn't match
-
-  return 0;
-}
-
-
-// crc functions --------------------------------------------------------------
-// crc-6 generator polynomial
-// g(x) = x^6 + a5*x^5 + ... + a1*x + a0
-
-// g(x) = x^6 + x + 1  
-#define CRC6_GEN_POL 0x30  // MSB=a0 LSB=a5    
-
-// g(x) = x^6 + x^2 + x + 1 (See:  https://users.ece.cmu.edu/~koopman/crc/)
-// #define CRC6_GEN_POL 0x38  // MSB=a0 LSB=a5. Simulation results are similar
-
-static int calc_crc6(const int *x, int sz)
-{
-  // todo: compute it faster using a look up table
-  int k,j,t,sr = 0;
-  for (k=0;k<sz;k++) {
-    t = x[k];
-    for (j=0;j<6;j++) {
-      if ((t^sr)&0x01)
-	sr = (sr>>1) ^ CRC6_GEN_POL;
-      else
-	sr = (sr>>1);
-      t>>=1;
-    }
-  }
-  return sr;
-}
-
-static void ix_mask(float *dst, const float *src, const int *mask, 
-		    const int *x)
-{
-  // mask intrinsic information (channel observations) with a priori knowledge
-	
-  int k,kk, smask;
-  float *row;
-
-  memcpy(dst,src,(QRA64_NC*QRA64_M)*sizeof(float));
-
-  for (k=0;k<QRA64_K;k++) {	// we can mask only information symbols distrib
-    smask = mask[k];
-    row = PD_ROWADDR(dst,QRA64_M,k);
-    if (smask) {
-      for (kk=0;kk<QRA64_M;kk++) 
-	if (((kk^x[k])&smask)!=0)
-	  *(row+kk) = 0.f;
-
-      pd_norm(row,QRA64_m);
-    }
-  }
-}
-
-// encode/decode msgs as done in JT65
-void encodemsg_jt65(int *y, const int call1, const int call2, const int grid)
-{
-  y[0]= (call1>>22)&0x3F;
-  y[1]= (call1>>16)&0x3F;
-  y[2]= (call1>>10)&0x3F;
-  y[3]= (call1>>4)&0x3F;
-  y[4]= (call1<<2)&0x3F;
-
-  y[4] |= (call2>>26)&0x3F;
-  y[5]= (call2>>20)&0x3F;
-  y[6]= (call2>>14)&0x3F;
-  y[7]= (call2>>8)&0x3F;
-  y[8]= (call2>>2)&0x3F;
-  y[9]= (call2<<4)&0x3F;
-
-  y[9] |= (grid>>12)&0x3F;
-  y[10]= (grid>>6)&0x3F;
-  y[11]= (grid)&0x3F;
-
-}
-void decodemsg_jt65(int *call1, int *call2, int *grid, const int *x)
-{
-  int nc1, nc2, ng;
-
-  nc1 = x[4]>>2;
-  nc1 |= x[3]<<4;
-  nc1 |= x[2]<<10;
-  nc1 |= x[1]<<16;
-  nc1 |= x[0]<<22;
-
-  nc2 = x[9]>>4;
-  nc2 |= x[8]<<2;
-  nc2 |= x[7]<<8;
-  nc2 |= x[6]<<14;
-  nc2 |= x[5]<<20;
-  nc2 |= (x[4]&0x03)<<26;
-
-  ng   = x[11];
-  ng  |= x[10]<<6;
-  ng  |= (x[9]&0x0F)<<12;
-
-  *call1 = nc1;
-  *call2 = nc2;
-  *grid  = ng;
-}
diff --git a/lib/qra/qra64/qra64_subs.c b/lib/qra/qra64/qra64_subs.c
deleted file mode 100644
index b60f9fafa..000000000
--- a/lib/qra/qra64/qra64_subs.c
+++ /dev/null
@@ -1,65 +0,0 @@
-// qra64_subs.c
-// Fortran interface routines for QRA64
-
-#include "qra64.h"
-#include <stdio.h>
-
-static qra64codec *pqra64codec = NULL;
-
-void qra64_enc_(int x[], int y[])
-{
-  if (pqra64codec==NULL) pqra64codec = qra64_init(QRA_USERAP);  
-  qra64_encode(pqra64codec, y, x);
-}
-
-void qra64_dec_(float r[], int* nc1, int* nc2, int* ng2, int* APtype, 
-		int* iset, int* ns0, float* b0, int* nf0,
-		int xdec[], float* snr, int* rc)
-{
-/*
-  APtype:                         AP
------------------------------------------------------------------------
-     -1                            0     (no AP information)
-      0    [CQ/QRZ    ?      ? ]  25/37
-      1    [MyCall    ?      ? ]  25/37
-      2    [  ?    HisCall   ? ]  25/37
-      3    [MyCall HisCall   ? ]  49/68
-      4    [MyCall HisCall grid]  68
-      5    [CQ/QRZ HisCall   ? ]  49/68
-
-     rc    Message format         AP APTYPE Comments
-------------------------------------------------------------------------
-    -16                                     Failed sanity check
-     -2                                     Decoded but CRC failed
-     -1                                     No decode
-      0    [   ?      ?      ? ]   0   -1   Decode with no AP info
-      1    [CQ/QRZ    ?      ? ]  25    0
-      2    [CQ/QRZ    ?      _ ]  37    0
-      3    [MyCall    ?      ? ]  25    1
-      4    [MyCall    ?      _ ]  37    1
-      5    [MyCall HisCall   ? ]  49    3
-      6    [   ?   HisCall   ? ]  25    2   Optional
-      7    [   ?   HisCall   _ ]  37    2   Optional
-      8    [MyCall HisCall Grid]  68    4
-      9    [CQ/QRZ HisCall   ? ]  49    5   Optional (not needed?)
-     10    [CQ/QRZ HisCall   _ ]  68    5   Optional
-     11    [CQ/QRZ HisCall Grid]  68    ?   Optional
-*/
-
-  float EbNodBEstimated;
-  int err=0;
-  int nSubmode=*ns0;
-  float b90=*b0;
-  int nFadingModel=*nf0;
-
-  if(pqra64codec==NULL) pqra64codec = qra64_init(QRA_USERAP);
-  err=qra64_apset(pqra64codec,*nc1,*nc2,*ng2,*APtype);
-  if(err<0) printf("ERROR: qra64_apset returned %d\n",err);
-
-  if(*iset==0) {
-    *rc = qra64_decode_fastfading(pqra64codec,&EbNodBEstimated,xdec,r,
-    				  nSubmode,b90,nFadingModel);
-    *snr = EbNodBEstimated - 31.0;
-  }
-}
-
diff --git a/lib/qra/qra64/qra64example.txt b/lib/qra/qra64/qra64example.txt
deleted file mode 100644
index 3add33d36..000000000
--- a/lib/qra/qra64/qra64example.txt
+++ /dev/null
@@ -1,88 +0,0 @@
-$ qra64_nico -h
-
-QRA64 Mode Tests
-2016, Nico Palermo - IV3NWV
-
----------------------------
-
-Syntax: qra64 [-s<snrdb>] [-c<channel>] [-a<ap-type>] [-t<testtype>] [-h]
-Options:
-       -s<snrdb>   : set simulation SNR in 2500 Hz BW (default:-27.5 dB)
-       -c<channel> : set channel type 0=AWGN (default) 1=Rayleigh
-       -a<ap-type> : set decode type 0=NOAP 1=AUTOAP (default) 2=USERAP
-       -t<testtype>: 0=simulate seq of msgs between IV3NWV and K1JT (default)
-                     1=simulate K1JT receiving K1JT IV3NWV JN66
-                     2=simulate fast-fading routines (option -c ignored)
-Options used only for fast-fading simulations:
-       -b          : 90% fading bandwidth in Hz [1..230 Hz] (default = 2.5 Hz)
-       -m          : fading model. 0=Gauss, 1=Lorentz (default = Lorentz)
-       -q          : qra64 submode. 0=QRA64A,... 4=QRA64E (default = QRA64A)
-       -h: this help
-
-
-#############################################################################
-Usage example:
-
-qra64 -c2 -t2 -a2 -b50 -m1 -q2 -s-26.0 -n50000
-
-Simulate a fast-fading channel (-c2)
-Evaluate decoder performance (-t2) with 
-USER_AP (-a2)
-B90 = 50 Hz (-b50)
-Lorentz model (-m1)
-submode QRA64C (-q2)
-Input SNR = -26.0 dB (-s-26.0)
-Simulate 50000 transmissions (-n50000)
-
-(type qra64 -h for command syntax)
-
-Command Output:
-
-Input SNR = -26.0dB ap-mode=USER AP
-
-Simulating the fast-fading channel
-B90=50.00 Hz - Fading Model=Lorentz - Submode=QRA64C
-Decoder metric = Matched to fast-fading signal
-
-Encoding msg [K1JT IV3NWV JN66]
-50000 transmissions will be simulated
-
-K1JT decoder enabled for [CQ    ?     ?/blank]
-K1JT decoder enabled for [K1JT  ?     ?/blank]
-K1JT decoder enabled for [?    IV3NWV ?/blank]
-K1JT decoder enabled for [K1JT IV3NWV ?]
-K1JT decoder enabled for [K1JT IV3NWV JN66]
-K1JT decoder enabled for [CQ   IV3NWV ?/b/JN66]
-
-Now decoding with K1JT's decoder...
-    5.5 %
-Undetected error with rc=6
-   13.1 %
-Undetected error with rc=7
-   70.8 %
-Undetected error with rc=1
-   75.8 %
-Undetected error with rc=9
-   88.9 %
-Undetected error with rc=6
-  100.0 %
-
-Msgs transmitted:50000
-Msg decoded:
-
-rc= 0     0 with [?    ?    ?] AP0
-rc= 1     0 with [CQ   ?    ?] AP27
-rc= 2     0 with [CQ   ?     ] AP42
-rc= 3   145 with [CALL ?    ?] AP29
-rc= 4     0 with [CALL ?     ] AP44
-rc= 5   12085 with [CALL CALL ?] AP57
-rc= 6     0 with [?    CALL ?] AP29
-rc= 7     0 with [?    CALL  ] AP44
-rc= 8   24307 with [CALL CALL G] AP72
-rc= 9     0 with [CQ   CALL ?] AP55
-rc=10     0 with [CQ   CALL  ] AP70
-rc=11     0 with [CQ   CALL G] AP70
-
-Total: 36537/50000 (5 undetected errors)
-
-Estimated SNR (average in dB) = -26.26 dB
diff --git a/lib/qra/qra64/qra64sim.f90 b/lib/qra/qra64/qra64sim.f90
deleted file mode 100644
index 2360ef7da..000000000
--- a/lib/qra/qra64/qra64sim.f90
+++ /dev/null
@@ -1,201 +0,0 @@
-program qra64sim
-
-! Generate simulated QRA64 data for testing the decoder.
-
-  use wavhdr
-  use packjt
-  parameter (NMAX=54*12000)              ! = 648,000
-  parameter (NFFT=10*65536,NH=NFFT/2)
-  type(hdr) h                            !Header for .wav file
-  integer*2 iwave(NMAX)                  !Generated waveform
-  integer*4 itone(84)                    !Channel symbols (values 0-63)
-  real*4 xnoise(NMAX)                    !Generated random noise
-  real*4 dat(NMAX)                       !Generated real data
-  complex cdat(NMAX)                     !Generated complex waveform
-  complex cspread(0:NFFT-1)              !Complex amplitude for Rayleigh fading
-  complex z
-  complex c00(0:720000)                  !Analytic signal for dat()
-  real*8 f0,dt,twopi,phi,dphi,baud,fsample,freq
-  character msg*22,fname*11,csubmode*1,arg*12,cd*1
-  character msgsent*22
-  logical lsync
-  data lsync/.false./
-
-  nargs=iargc()
-  if(nargs.ne.8) then
-     print*,'Usage:   qra64sim         "msg"     A-E Nsigs fDop DT Nfiles Sync SNR'
-     print*,'Example  qra64sim "K1ABC W9XYZ EN37" A   10   0.2 0.0   1      T  -26'
-     print*,'Sync = T to include sync test.'
-     go to 999
-  endif
-  call getarg(1,msg)
-  call getarg(2,csubmode)
-  mode64=2**(ichar(csubmode)-ichar('A'))
-  call getarg(3,arg)
-  read(arg,*) nsigs
-  call getarg(4,arg)
-  read(arg,*) fspread
-  call getarg(5,arg)
-  read(arg,*) xdt
-  call getarg(6,arg)
-  read(arg,*) nfiles
-  call getarg(7,arg)
-  if(arg(1:1).eq.'T' .or. arg(1:1).eq.'1') lsync=.true.
-  call getarg(8,arg)
-  read(arg,*) snrdb
-
-  if(mode64.ge.8) nsigs=1
-  rms=100.
-  fsample=12000.d0                   !Sample rate (Hz)
-  dt=1.d0/fsample                    !Sample interval (s)
-  twopi=8.d0*atan(1.d0)
-  npts=54*12000                      !Total samples in .wav file
-  nsps=6912
-  baud=12000.d0/nsps                 !Keying rate = 1.7361111111
-  nsym=84                            !Number of channel symbols
-  h=default_header(12000,npts)
-  dfsig=2000.0/nsigs                 !Freq spacing between sigs in file (Hz)
-  ichk=0
-
-  write(*,1000) 
-1000 format('File  Sig    Freq  A-E   S/N   DT   Dop    Message'/60('-'))
-
-  nsync=0
-  do ifile=1,nfiles                  !Loop over requested number of files
-     write(fname,1002) ifile         !Output filename
-1002 format('000000_',i4.4)
-     open(10,file=fname//'.wav',access='stream',status='unknown')
-     xnoise=0.
-     cdat=0.
-     if(snrdb.lt.90) then
-        do i=1,npts
-           xnoise(i)=gran()          !Generate gaussian noise
-        enddo
-     endif
-
-     do isig=1,nsigs                 !Generate requested number of sigs
-        if(mod(nsigs,2).eq.0) f0=1500.0 + dfsig*(isig-0.5-nsigs/2)
-        if(mod(nsigs,2).eq.1) f0=1500.0 + dfsig*(isig-(nsigs+1)/2)
-        if(nsigs.eq.1) f0=1000.0
-        xsnr=snrdb
-        if(snrdb.eq.0.0) xsnr=-20 - isig
-
-        call genqra64(msg,ichk,msgsent,itone,itype)
-
-        bandwidth_ratio=2500.0/6000.0
-        sig=sqrt(2*bandwidth_ratio)*10.0**(0.05*xsnr)
-        if(xsnr.gt.90.0) sig=1.0
-        write(*,1020) ifile,isig,f0,csubmode,xsnr,xdt,fspread,msg
-1020    format(i4,i4,f10.3,2x,a1,2x,f5.1,f6.2,f6.1,1x,a22)
-
-        phi=0.d0
-        dphi=0.d0
-        k=(xdt+1.0)*12000                   !Start audio at t = xdt + 1.0 s
-        isym0=-99
-        do i=1,npts                         !Add this signal into cdat()
-           isym=i/nsps + 1
-           if(isym.gt.nsym) exit
-           if(isym.ne.isym0) then
-              freq=f0 + itone(isym)*baud*mode64
-              dphi=twopi*freq*dt
-              isym0=isym
-           endif
-           phi=phi + dphi
-           if(phi.gt.twopi) phi=phi-twopi
-           xphi=phi
-           z=cmplx(cos(xphi),sin(xphi))
-           k=k+1
-           if(k.ge.1) cdat(k)=cdat(k) + sig*z
-        enddo
-     enddo
-
-     if(fspread.ne.0) then                  !Apply specified Doppler spread
-        df=12000.0/nfft
-        twopi=8*atan(1.0)
-        cspread(0)=1.0
-        cspread(NH)=0.
-        b=6.0                       !Use truncated Lorenzian shape for fspread
-        do i=1,NH
-           f=i*df
-           x=b*f/fspread
-           z=0.
-           a=0.
-           if(x.lt.3.0) then                          !Cutoff beyond x=3
-              a=sqrt(1.111/(1.0+x*x)-0.1)             !Lorentzian
-              call random_number(r1)
-              phi1=twopi*r1
-              z=a*cmplx(cos(phi1),sin(phi1))
-           endif
-           cspread(i)=z
-           z=0.
-           if(x.lt.50.0) then
-              call random_number(r2)
-              phi2=twopi*r2
-              z=a*cmplx(cos(phi2),sin(phi2))
-           endif
-           cspread(NFFT-i)=z
-        enddo
-
-!        do i=0,NFFT-1
-!           f=i*df
-!           if(i.gt.NH) f=(i-nfft)*df
-!           s=real(cspread(i))**2 + aimag(cspread(i))**2
-!          write(13,3000) i,f,s,cspread(i)
-!3000      format(i5,f10.3,3f12.6)
-!        enddo
-!        s=real(cspread(0))**2 + aimag(cspread(0))**2
-!        write(13,3000) 1024,0.0,s,cspread(0)
-
-        call four2a(cspread,NFFT,1,1,1)             !Transform to time domain
-
-        sum=0.
-        do i=0,NFFT-1
-           p=real(cspread(i))**2 + aimag(cspread(i))**2
-           sum=sum+p
-        enddo
-        avep=sum/NFFT
-        fac=sqrt(1.0/avep)
-        cspread=fac*cspread                   !Normalize to constant avg power
-        cdat=cspread(1:npts)*cdat             !Apply Rayleigh fading
-
-!        do i=0,NFFT-1
-!           p=real(cspread(i))**2 + aimag(cspread(i))**2
-!           write(14,3010) i,p,cspread(i)
-!3010       format(i8,3f12.6)
-!        enddo
-
-     endif
-
-     dat=aimag(cdat) + xnoise                 !Add the generated noise
-     fac=32767.0/nsigs
-     if(snrdb.ge.90.0) iwave(1:npts)=nint(fac*dat(1:npts))
-     if(snrdb.lt.90.0) iwave(1:npts)=nint(rms*dat(1:npts))
-     write(10) h,iwave(1:npts)                !Save the .wav file
-     close(10)
-
-     if(lsync) then
-        cd=' '
-        if(ifile.eq.nfiles) cd='d'
-        nf1=200
-        nf2=3000
-        nfqso=nint(f0)
-        ntol=100
-        minsync=0
-        emedelay=0.0
-        call ana64(dat,npts,c00)
-        call sync64(c00,nf1,nf2,nfqso,ntol,minsync,mode64,emedelay,xdt2,f02,  &
-             jpk0,sync,sync2,width)
-        terr=1.01/(8.0*baud)
-        ferr=1.01*mode64*baud
-        if(abs(xdt2-xdt).lt.terr .and. abs(f02-f0).lt.ferr) nsync=nsync+1
-        open(40,file='sync64.out',status='unknown',position='append')
-        write(40,1030) ifile,64,csubmode,snrdb,fspread,xdt2-xdt,f02-f0,   &
-             width,sync,sync2,nsync,cd
-1030    format(i4,i3,1x,a1,2f7.1,f7.2,4f8.1,i5,1x,a1)
-        close(40)
-     endif
-  enddo
-  if(lsync) write(*,1040) snrdb,nfiles,nsync
-1040 format('SNR:',f6.1,'   nfiles:',i5,'   nsynced:',i5)
-
-999 end program qra64sim
diff --git a/lib/qra_loops.f90 b/lib/qra_loops.f90
deleted file mode 100644
index cebd7036a..000000000
--- a/lib/qra_loops.f90
+++ /dev/null
@@ -1,137 +0,0 @@
-subroutine qra_loops(c00,npts2,nsps,mode,mode64,nsubmode,nFadingModel,   &
-     ndepth,nc1,nc2,ng2,naptype,jpk0,xdt,f0,width,snr2,irc,dat4)
-
-  use packjt
-  use timer_module, only: timer
-  parameter (LN=2176*63)           !LN=LL*NN; LL = 64*(mode64+2)
-  character*37 decoded
-  complex c00(0:npts2-1)           !Analytic representation of dd(), 6000 Hz
-  complex ,allocatable :: c0(:)    !Ditto, with freq shift
-  real a(3)                        !twkfreq params f,f1,f2
-  real s3(LN)                      !Symbol spectra
-  real s3avg(LN)                   !Averaged symbol spectra
-  integer dat4(12),dat4x(12)       !Decoded message (as 12 integers)
-  integer nap(0:11)                !AP return codes
-  data nap/0,2,3,2,3,4,2,3,6,4,6,6/,nsave/0/
-  save nsave,s3avg
-
-  allocate(c0(0:npts2-1))
-  irc=-99
-  s3lim=20.
-  ibwmax=11
-  if(mode64.le.4) ibwmax=9
-  ibwmin=ibwmax
-  idtmax=3
-  call qra_params(ndepth,maxaptype,idfmax,idtmax,ibwmin,ibwmax,maxdist)
-  LL=64*(mode64+2)
-  NN=63
-  napmin=99
-  ncall=0
-
-  do iavg=0,1
-     if(iavg.eq.1) then
-        idfmax=1
-        idtmax=1
-     endif
-     do idf=1,idfmax
-        ndf=idf/2
-        if(mod(idf,2).eq.0) ndf=-ndf
-        a=0.
-        a(1)=-(f0+0.4*ndf)
-        call twkfreq(c00,c0,npts2,6000.0,a)
-        do idt=1,idtmax
-           ndt=idt/2
-           if(iavg.eq.0) then
-              if(mod(idt,2).eq.0) ndt=-ndt
-              jpk=jpk0 + 240*ndt                  !240/6000 = 0.04 s = tsym/32
-              if(jpk.lt.0) jpk=0
-              call timer('spec64  ',0)
-              call spec64(c0,nsps,mode,mode64,jpk,s3,LL,NN)
-              call timer('spec64  ',1)
-              call pctile(s3,LL*NN,40,base)
-              s3=s3/base
-              where(s3(1:LL*NN)>s3lim) s3(1:LL*NN)=s3lim
-           else
-              s3(1:LL*NN)=s3avg(1:LL*NN)
-           endif
-           do ibw=ibwmax,ibwmin,-2
-              ndist=ndf**2 + ndt**2 + ((ibwmax-ibw)/2)**2
-              if(ndist.gt.maxdist) cycle
-              b90=1.728**ibw
-              if(b90.gt.230.0) cycle
-              if(b90.lt.0.15*width) exit
-              ncall=ncall+1
-              call timer('qra64_de',0)
-              call qra64_dec(s3,nc1,nc2,ng2,naptype,0,nSubmode,b90,      &
-                   nFadingModel,dat4,snr2,irc)
-              call timer('qra64_de',1)
-              if(irc.eq.0) go to 200
-              if(irc.gt.0) call badmsg(irc,dat4,nc1,nc2,ng2)
-              iirc=max(0,min(irc,11))
-              if(irc.gt.0 .and. nap(iirc).lt.napmin) then
-                 dat4x=dat4
-                 b90x=b90
-                 snr2x=snr2
-                 napmin=nap(iirc)
-                 irckeep=irc
-                 xdtkeep=jpk/6000.0 - 1.0
-                 f0keep=-a(1)
-                 idfkeep=idf
-                 idtkeep=idt
-                 ibwkeep=ibw
-                 ndistx=ndist
-                 go to 100   !###
-              endif
-           enddo  ! ibw (b90 loop)
-           !###        if(iand(ndepth,3).lt.3 .and. irc.ge.0) go to 100
-        enddo  ! idt (DT loop)
-     enddo  ! idf (f0 loop)
-!     if(iavg.eq.0 .and. abs(jpk0-4320).le.1300) then
-     if(iavg.eq.0) then
-        a=0.
-        a(1)=-f0
-        call twkfreq(c00,c0,npts2,6000.0,a)
-        jpk=3000                                 !###  These definitions need work ###
-!       if(nsps.ge.3600) jpk=4080                !###
-        if(nsps.ge.3600) jpk=6000                !###
-        call spec64(c0,nsps,mode,mode64,jpk,s3,LL,NN)
-        call pctile(s3,LL*NN,40,base)
-        s3=s3/base
-        where(s3(1:LL*NN)>s3lim) s3(1:LL*NN)=s3lim
-        s3avg(1:LL*NN)=s3avg(1:LL*NN)+s3(1:LL*NN)
-        nsave=nsave+1
-     endif
-     if(iavg.eq.0 .and. nsave.lt.2) exit
-  enddo  ! iavg 
-  
-100 if(napmin.ne.99) then
-     dat4=dat4x
-     b90=b90x
-     snr2=snr2x
-     irc=irckeep
-     xdt=xdtkeep
-     f0=f0keep
-     idt=idtkeep
-     idf=idfkeep
-     ibw=ibwkeep
-     ndist=ndistx
-  endif
-
-200 if(mode.eq.65 .and. nsps.eq.7200/2) xdt=xdt+0.4 !### Empirical -- WHY ??? ###
-
-  if(irc.ge.0) then
-     navg=nsave
-     if(iavg.eq.0) navg=0
-     !### For tests only:
-     open(53,file='fort.53',status='unknown',position='append')
-     call unpackmsg(dat4,decoded)               !Unpack the user message
-     write(53,3053) idf,idt,ibw,b90,xdt,f0,snr2,ndist,irc,navg,decoded(1:22)
-3053 format(3i5,f7.1,f7.2,2f7.1,3i4,2x,a22)
-     close(53)
-     !###  
-     nsave=0
-     s3avg=0.
-     irc=irc + 100*navg
-  endif
-  return
-end subroutine qra_loops