Initial Commit

2018-02-08 21:28:33 -05:00
commit 678c1d3966
14352 changed files with 3176737 additions and 0 deletions
@@ -0,0 +1,17 @@
+# /* **************************************************************************
+#  *                                                                          *
+#  *     (C) Copyright Paul Mensonides 2002.
+#  *     Distributed under the Boost Software License, Version 1.0. (See
+#  *     accompanying file LICENSE_1_0.txt or copy at
+#  *     http://www.boost.org/LICENSE_1_0.txt)
+#  *                                                                          *
+#  ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_REPEAT_2ND_HPP
+# define BOOST_PREPROCESSOR_REPEAT_2ND_HPP
+#
+# include <boost/preprocessor/repetition/repeat.hpp>
+#
+# endif
@@ -0,0 +1,80 @@
+#ifndef COMMONS_H
+#define COMMONS_H
+
+#define NSMAX 6827
+#define NTMAX 300
+#define RX_SAMPLE_RATE 12000
+
+#ifdef __cplusplus
+#include <cstdbool>
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+  /*
+   * This structure is shared with Fortran code, it MUST be kept in
+   * sync with lib/jt9com.f90
+   */
+extern struct dec_data {
+  float ss[184*NSMAX];
+  float savg[NSMAX];
+  float sred[5760];
+  short int d2[NTMAX*RX_SAMPLE_RATE];
+  struct
+  {
+    int nutc;                   //UTC as integer, HHMM
+    bool ndiskdat;              //true ==> data read from *.wav file
+    int ntrperiod;              //TR period (seconds)
+    int nfqso;                  //User-selected QSO freq (kHz)
+    bool newdat;                //true ==> new data, must do long FFT
+    int npts8;                  //npts for c0() array
+    int nfa;                    //Low decode limit (Hz)
+    int nfSplit;                //JT65 | JT9 split frequency
+    int nfb;                    //High decode limit (Hz)
+    int ntol;                   //+/- decoding range around fQSO (Hz)
+    int kin;
+    int nzhsym;
+    int nsubmode;
+    bool nagain;
+    int ndepth;
+    int ntxmode;
+    int nmode;
+    int minw;
+    bool nclearave;
+    int minSync;
+    float emedelay;
+    float dttol;
+    int nlist;
+    int listutc[10];
+    int n2pass;
+    int nranera;
+    int naggressive;
+    bool nrobust;
+    int nexp_decode;
+    char datetime[20];
+    char mycall[12];
+    char mygrid[6];
+    char hiscall[12];
+    char hisgrid[6];
+  } params;
+} dec_data;
+
+extern struct {
+  float syellow[NSMAX];
+  float ref[3457];
+  float filter[3457];
+} spectra_;
+
+extern struct {
+  int   nclearave;
+  int   nsum;
+  float blue[4096];
+  float red[4096];
+} echocom_;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // COMMONS_H
@@ -0,0 +1,112 @@
+# Version 1.0 (2013-04-12)
+# Public Domain, originally written by Lasse Kärkkäinen <tronic@zi.fi>
+# Published at http://www.cmake.org/Wiki/CMake:How_To_Find_Libraries
+
+# If you improve the script, please modify the forementioned wiki page because
+# I no longer maintain my scripts (hosted as static files at zi.fi). Feel free
+# to remove this entire header if you use real version control instead.
+
+# Changelog:
+# 2013-04-12  Added version number (1.0) and this header, no other changes
+# 2009-10-08  Originally published
+
+
+# Works the same as find_package, but forwards the "REQUIRED" and "QUIET" arguments
+# used for the current package. For this to work, the first parameter must be the
+# prefix of the current package, then the prefix of the new package etc, which are
+# passed to find_package.
+macro (libfind_package PREFIX)
+  set (LIBFIND_PACKAGE_ARGS ${ARGN})
+  if (${PREFIX}_FIND_QUIETLY)
+    set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET)
+  endif (${PREFIX}_FIND_QUIETLY)
+  if (${PREFIX}_FIND_REQUIRED)
+    set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED)
+  endif (${PREFIX}_FIND_REQUIRED)
+  find_package(${LIBFIND_PACKAGE_ARGS})
+endmacro (libfind_package)
+
+# CMake developers made the UsePkgConfig system deprecated in the same release (2.6)
+# where they added pkg_check_modules. Consequently I need to support both in my scripts
+# to avoid those deprecated warnings. Here's a helper that does just that.
+# Works identically to pkg_check_modules, except that no checks are needed prior to use.
+macro (libfind_pkg_check_modules PREFIX PKGNAME)
+  if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    include(UsePkgConfig)
+    pkgconfig(${PKGNAME} ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARY_DIRS ${PREFIX}_LDFLAGS ${PREFIX}_CFLAGS)
+  else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    find_package(PkgConfig)
+    if (PKG_CONFIG_FOUND)
+      pkg_check_modules(${PREFIX} ${PKGNAME})
+    endif (PKG_CONFIG_FOUND)
+  endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+endmacro (libfind_pkg_check_modules)
+
+# Do the final processing once the paths have been detected.
+# If include dirs are needed, ${PREFIX}_PROCESS_INCLUDES should be set to contain
+# all the variables, each of which contain one include directory.
+# Ditto for ${PREFIX}_PROCESS_LIBS and library files.
+# Will set ${PREFIX}_FOUND, ${PREFIX}_INCLUDE_DIRS and ${PREFIX}_LIBRARIES.
+# Also handles errors in case library detection was required, etc.
+macro (libfind_process PREFIX)
+  # Skip processing if already processed during this run
+  if (NOT ${PREFIX}_FOUND)
+    # Start with the assumption that the library was found
+    set (${PREFIX}_FOUND TRUE)
+
+    # Process all includes and set _FOUND to false if any are missing
+    foreach (i ${${PREFIX}_PROCESS_INCLUDES})
+      if (${i})
+        set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}})
+        mark_as_advanced(${i})
+      else (${i})
+        set (${PREFIX}_FOUND FALSE)
+      endif (${i})
+    endforeach (i)
+
+    # Process all libraries and set _FOUND to false if any are missing
+    foreach (i ${${PREFIX}_PROCESS_LIBS})
+      if (${i})
+        set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}})
+        mark_as_advanced(${i})
+      else (${i})
+        set (${PREFIX}_FOUND FALSE)
+      endif (${i})
+    endforeach (i)
+
+    # Print message and/or exit on fatal error
+    if (${PREFIX}_FOUND)
+      if (NOT ${PREFIX}_FIND_QUIETLY)
+        message (STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}")
+      endif (NOT ${PREFIX}_FIND_QUIETLY)
+    else (${PREFIX}_FOUND)
+      if (${PREFIX}_FIND_REQUIRED)
+        foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS})
+          message("${i}=${${i}}")
+        endforeach (i)
+        message (FATAL_ERROR "Required library ${PREFIX} NOT FOUND.\nInstall the library (dev version) and try again. If the library is already installed, use ccmake to set the missing variables manually.")
+      endif (${PREFIX}_FIND_REQUIRED)
+    endif (${PREFIX}_FOUND)
+  endif (NOT ${PREFIX}_FOUND)
+endmacro (libfind_process)
+
+macro(libfind_library PREFIX basename)
+  set(TMP "")
+  if(MSVC80)
+    set(TMP -vc80)
+  endif(MSVC80)
+  if(MSVC90)
+    set(TMP -vc90)
+  endif(MSVC90)
+  set(${PREFIX}_LIBNAMES ${basename}${TMP})
+  if(${ARGC} GREATER 2)
+    set(${PREFIX}_LIBNAMES ${basename}${TMP}-${ARGV2})
+    string(REGEX REPLACE "\\." "_" TMP ${${PREFIX}_LIBNAMES})
+    set(${PREFIX}_LIBNAMES ${${PREFIX}_LIBNAMES} ${TMP})
+  endif(${ARGC} GREATER 2)
+  find_library(${PREFIX}_LIBRARY
+    NAMES ${${PREFIX}_LIBNAMES}
+    PATHS ${${PREFIX}_PKGCONF_LIBRARY_DIRS}
+  )
+endmacro(libfind_library)
+
@@ -0,0 +1,726 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1
+      , typename A0 , typename A1
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            2
+          , RT
+          , RT(*)(T0 , T1)
+        >
+      , A0 , A1
+    >::type const
+    bind(
+        RT(*f)(T0 , T1)
+      , A0 const& a0 , A1 const& a1
+    )
+    {
+        typedef detail::function_ptr<
+            2
+          , RT
+          , RT(*)(T0 , T1)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1
+            >::make(
+                fp_type(f)
+              , a0 , a1
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2
+      , typename A0 , typename A1 , typename A2
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            3
+          , RT
+          , RT(*)(T0 , T1 , T2)
+        >
+      , A0 , A1 , A2
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2
+    )
+    {
+        typedef detail::function_ptr<
+            3
+          , RT
+          , RT(*)(T0 , T1 , T2)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3
+      , typename A0 , typename A1 , typename A2 , typename A3
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            4
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3)
+        >
+      , A0 , A1 , A2 , A3
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
+    )
+    {
+        typedef detail::function_ptr<
+            4
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            5
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4)
+        >
+      , A0 , A1 , A2 , A3 , A4
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
+    )
+    {
+        typedef detail::function_ptr<
+            5
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            6
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
+    )
+    {
+        typedef detail::function_ptr<
+            6
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            7
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
+    )
+    {
+        typedef detail::function_ptr<
+            7
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            8
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
+    )
+    {
+        typedef detail::function_ptr<
+            8
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            9
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
+    )
+    {
+        typedef detail::function_ptr<
+            9
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            10
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
+    )
+    {
+        typedef detail::function_ptr<
+            10
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            11
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10
+    )
+    {
+        typedef detail::function_ptr<
+            11
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            12
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11
+    )
+    {
+        typedef detail::function_ptr<
+            12
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            13
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12
+    )
+    {
+        typedef detail::function_ptr<
+            13
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            14
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13
+    )
+    {
+        typedef detail::function_ptr<
+            14
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            15
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14
+    )
+    {
+        typedef detail::function_ptr<
+            15
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            16
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15
+    )
+    {
+        typedef detail::function_ptr<
+            16
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            17
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16
+    )
+    {
+        typedef detail::function_ptr<
+            17
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            18
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17
+    )
+    {
+        typedef detail::function_ptr<
+            18
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17
+            );
+    }
+    
+    
+    
+    
+    
+    
+    
+    template <
+        typename RT
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18
+    >
+    inline
+    typename detail::expression::function_eval<
+        detail::function_ptr<
+            19
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)
+        >
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18
+    >::type const
+    bind(
+        RT(*f)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)
+      , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17 , A18 const& a18
+    )
+    {
+        typedef detail::function_ptr<
+            19
+          , RT
+          , RT(*)(T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)
+        > fp_type;
+        return
+            detail::expression::function_eval<
+                fp_type
+              , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18
+            >::make(
+                fp_type(f)
+              , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18
+            );
+    }
@@ -0,0 +1,80 @@
+//  Copyright Neil Groves 2009. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FIND_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FIND_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+    namespace range
+    {
+
+/// \brief template function find
+///
+/// range-based version of the find std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+template< class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+>::type
+find( SinglePassRange& rng, const Value& val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::find(boost::begin(rng), boost::end(rng), val);
+}
+
+/// \overload
+template< class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+find( const SinglePassRange& rng, const Value& val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::find(boost::begin(rng), boost::end(rng), val);
+}
+
+// range_return overloads
+
+/// \overload
+template< range_return_value re, class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange>,
+    BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+>::type
+find( SinglePassRange& rng, const Value& val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return range_return<SinglePassRange,re>::
+        pack(std::find(boost::begin(rng), boost::end(rng), val),
+             rng);
+}
+
+/// \overload
+template< range_return_value re, class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+find( const SinglePassRange& rng, const Value& val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return range_return<const SinglePassRange,re>::
+        pack(std::find(boost::begin(rng), boost::end(rng), val),
+             rng);
+}
+
+    } // namespace range
+    using range::find;
+}
+
+#endif // include guard
@@ -0,0 +1,25 @@
+//  (C) Copyright Artyom Beilis 2010.  
+//  Use, modification and distribution are subject to the  
+//  Boost Software License, Version 1.0. (See accompanying file  
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 
+
+#ifndef BOOST_CONFIG_PLATFORM_VMS_HPP 
+#define BOOST_CONFIG_PLATFORM_VMS_HPP 
+
+#define BOOST_PLATFORM "OpenVMS" 
+
+#undef  BOOST_HAS_STDINT_H 
+#define BOOST_HAS_UNISTD_H 
+#define BOOST_HAS_NL_TYPES_H 
+#define BOOST_HAS_GETTIMEOFDAY 
+#define BOOST_HAS_DIRENT_H 
+#define BOOST_HAS_PTHREADS 
+#define BOOST_HAS_NANOSLEEP 
+#define BOOST_HAS_CLOCK_GETTIME 
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 
+#define BOOST_HAS_LOG1P 
+#define BOOST_HAS_EXPM1 
+#define BOOST_HAS_THREADS 
+#undef  BOOST_HAS_SCHED_YIELD 
+
+#endif 
@@ -0,0 +1,45 @@
+/*==============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2010 Eric Niebler
+    Copyright (c) 2010 Thomas Heller
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#ifndef BOOST_PHOENIX_STATEMENT_SEQUENCE_HPP
+#define BOOST_PHOENIX_STATEMENT_SEQUENCE_HPP
+
+#include <boost/phoenix/core/limits.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/phoenix/core/meta_grammar.hpp>
+#include <boost/proto/operators.hpp> // Included to solve #5715
+
+namespace boost { namespace phoenix
+{
+    namespace expression
+    {
+        template <typename A0, typename A1>
+        struct sequence
+            : expr<proto::tag::comma, A0, A1>
+        {};
+    }
+
+    namespace rule
+    {
+        struct sequence
+            : expression::sequence<
+                meta_grammar
+              , meta_grammar
+            >
+        {};
+    }
+
+    template <typename Dummy>
+    struct meta_grammar::case_<proto::tag::comma, Dummy>
+        : enable_rule<rule::sequence, Dummy>
+    {};
+
+}}
+
+#endif
@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(FUSION_VALUE_OF_IMPL_07202005_0900)
+#define FUSION_VALUE_OF_IMPL_07202005_0900
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+
+namespace boost { namespace fusion
+{
+    struct reverse_view_iterator_tag;
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+
+        template <>
+        struct value_of_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::value_of<
+                        typename result_of::prior<
+                            typename Iterator::first_type
+                        >::type
+                    >::type
+                type;
+            };
+        };
+    }
+}}
+
+#endif
+
+
@@ -0,0 +1,100 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+# ifndef INVOKE_DWA20021122_HPP
+#  define INVOKE_DWA20021122_HPP
+
+#  include <boost/python/detail/prefix.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/none.hpp>
+
+#  include <boost/type_traits/is_member_function_pointer.hpp>
+
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/facilities/intercept.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#  include <boost/python/to_python_value.hpp>
+
+// This file declares a series of overloaded invoke(...)  functions,
+// used to invoke wrapped C++ function (object)s from Python. Each one
+// accepts:
+//
+//   - a tag which identifies the invocation syntax (e.g. member
+//   functions must be invoked with a different syntax from regular
+//   functions)
+//
+//   - a pointer to a result converter type, used solely as a way of
+//   transmitting the type of the result converter to the function (or
+//   an int, if the return type is void).
+//
+//   - the "function", which may be a function object, a function or
+//   member function pointer, or a defaulted_virtual_fn.
+//
+//   - The arg_from_python converters for each of the arguments to be
+//   passed to the function being invoked.
+
+namespace boost { namespace python { namespace detail { 
+
+// This "result converter" is really just used as a dispatch tag to
+// invoke(...), selecting the appropriate implementation
+typedef int void_result_to_python;
+
+template <bool void_return, bool member>
+struct invoke_tag_ {};
+
+// A metafunction returning the appropriate tag type for invoking an
+// object of type F with return type R.
+template <class R, class F>
+struct invoke_tag
+  : invoke_tag_<
+        is_same<R,void>::value
+      , is_member_function_pointer<F>::value
+    >
+{
+};
+
+#  define BOOST_PP_ITERATION_PARAMS_1                                            \
+        (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/invoke.hpp>))
+#  include BOOST_PP_ITERATE()
+
+}}} // namespace boost::python::detail
+
+# endif // INVOKE_DWA20021122_HPP
+#else 
+
+# define N BOOST_PP_ITERATION()
+
+template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    return rc(f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) ));
+}
+                 
+template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) );
+    return none();
+}
+
+template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    return rc( (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT)) );
+}
+                 
+template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT));
+    return none();
+}
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING 
@@ -0,0 +1,64 @@
+12000 61 250 750 0.2 50, mix at 1500
+
+
+-0.000000000000  0.001944450121
+-0.000668730681  0.000668730681
+-0.000974850191 -0.000000000000
+-0.000581679123 -0.000581679123
+ 0.000000000000 -0.000439648787
+-0.000148911451  0.000148911451
+-0.001140891736 -0.000000000000
+-0.001653102965 -0.001653102965
+ 0.000000000000 -0.003749915818
+ 0.003740834397 -0.003740834397
+ 0.006834087490  0.000000000000
+ 0.005812808655  0.005812808655
+-0.000000000000  0.009262713933
+-0.006900370427  0.006900370427
+-0.009503248519 -0.000000000000
+-0.005874581677 -0.005874581677
+ 0.000000000000 -0.006017530719
+ 0.001785268072 -0.001785268072
+-0.002214736448 -0.000000000000
+-0.005777038427 -0.005777038427
+ 0.000000000000 -0.015228682747
+ 0.016402831440 -0.016402831440
+ 0.031806920774  0.000000000000
+ 0.028800401613  0.028800401613
+-0.000000000000  0.049589395998
+-0.041000303659  0.041000303659
+-0.065514139214 -0.000000000000
+-0.050781544715 -0.050781544715
+ 0.000000000000 -0.076562341482
+ 0.056225821996 -0.056225821996
+ 0.080516569816  0.000000000000
+ 0.056225821996  0.056225821996
+-0.000000000000  0.076562341482
+-0.050781544715  0.050781544715
+-0.065514139214 -0.000000000000
+-0.041000303659 -0.041000303659
+ 0.000000000000 -0.049589395998
+ 0.028800401613 -0.028800401613
+ 0.031806920774  0.000000000000
+ 0.016402831440  0.016402831440
+-0.000000000000  0.015228682747
+-0.005777038427  0.005777038427
+-0.002214736448 -0.000000000000
+ 0.001785268072  0.001785268072
+-0.000000000000  0.006017530719
+-0.005874581677  0.005874581677
+-0.009503248519 -0.000000000000
+-0.006900370427 -0.006900370427
+ 0.000000000000 -0.009262713933
+ 0.005812808655 -0.005812808655
+ 0.006834087490  0.000000000000
+ 0.003740834397  0.003740834397
+-0.000000000000  0.003749915818
+-0.001653102965  0.001653102965
+-0.001140891736 -0.000000000000
+-0.000148911451 -0.000148911451
+-0.000000000000  0.000439648787
+-0.000581679123  0.000581679123
+-0.000974850191 -0.000000000000
+-0.000668730681 -0.000668730681
+ 0.000000000000 -0.001944450121
@@ -0,0 +1,77 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_TRAITS_HPP
+#define BOOST_MOVE_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/move/core.hpp>
+#endif
+#include <boost/move/detail/meta_utils.hpp>
+#include <boost/move/detail/type_traits.hpp>
+
+namespace boost {
+
+//! If this trait yields to true
+//! (<i>has_trivial_destructor_after_move &lt;T&gt;::value == true</i>)
+//! means that if T is used as argument of a move construction/assignment,
+//! there is no need to call T's destructor.
+//! This optimization tipically is used to improve containers' performance.
+//!
+//! By default this trait is true if the type has trivial destructor,
+//! every class should specialize this trait if it wants to improve performance
+//! when inserted in containers.
+template <class T>
+struct has_trivial_destructor_after_move
+   : ::boost::move_detail::is_trivially_destructible<T>
+{};
+
+//! By default this traits returns
+//! <pre>boost::is_nothrow_move_constructible<T>::value && boost::is_nothrow_move_assignable<T>::value </pre>.
+//! Classes with non-throwing move constructor
+//! and assignment can specialize this trait to obtain some performance improvements.
+template <class T>
+struct has_nothrow_move
+{
+   static const bool value = boost::move_detail::is_nothrow_move_constructible<T>::value &&
+                             boost::move_detail::is_nothrow_move_assignable<T>::value;
+};
+
+namespace move_detail {
+
+template <class T>
+struct is_nothrow_move_constructible_or_uncopyable
+{
+   //The standard requires is_nothrow_move_constructible for move_if_noexcept
+   //but a user (usually in C++03) might specialize has_nothrow_move which includes it
+   static const bool value = is_nothrow_move_constructible<T>::value ||
+                             has_nothrow_move<T>::value ||
+                            !is_copy_constructible<T>::value;
+};
+
+}  //move_detail {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_TRAITS_HPP
@@ -0,0 +1,90 @@
+//
+// MessageAggregator - an example application that utilizes the WSJT-X
+//                     messaging facility
+//
+// This  application is  only  provided as  a  simple GUI  application
+// example to demonstrate the WSJT-X messaging facility. It allows the
+// user to set  the server details either as a  unicast UDP server or,
+// if a  multicast group address  is provided, as a  multicast server.
+// The benefit of the multicast server is that multiple servers can be
+// active at  once each  receiving all  WSJT-X broadcast  messages and
+// each able to  respond to individual WSJT_X clients.  To utilize the
+// multicast  group features  each  WSJT-X client  must  set the  same
+// multicast  group address  as  the UDP  server  address for  example
+// 239.255.0.0 for a site local multicast group.
+//
+// The  UI is  a small  panel  to input  the service  port number  and
+// optionally  the  multicast  group  address.   Below  that  a  table
+// representing  the  log  entries   where  any  QSO  logged  messages
+// broadcast  from WSJT-X  clients are  displayed. The  bottom of  the
+// application main  window is a  dock area  where a dock  window will
+// appear for each WSJT-X client, this  window contains a table of the
+// current decode  messages broadcast  from that  WSJT-X client  and a
+// status line showing  the status update messages  broadcast from the
+// WSJT-X client. The dock windows may  be arranged in a tab bar, side
+// by side,  below each  other or, completely  detached from  the dock
+// area as floating windows. Double clicking the dock window title bar
+// or  dragging and  dropping with  the mouse  allows these  different
+// arrangements.
+//
+// The application  also provides a  simple menu bar including  a view
+// menu that allows each dock window to be hidden or revealed.
+//
+
+#include <clocale>
+#include <iostream>
+#include <exception>
+
+#include <QFile>
+#include <QApplication>
+#include <QMessageBox>
+#include <QObject>
+
+#include "MessageAggregatorMainWindow.hpp"
+
+// deduce the size of an array
+template<class T, size_t N>
+inline
+size_t size (T (&)[N]) {return N;}
+
+int main (int argc, char * argv[])
+{
+  QApplication app {argc, argv};
+  try
+    {
+      setlocale (LC_NUMERIC, "C"); // ensure number forms are in
+                                   // consistent format, do this after
+                                   // instantiating QApplication so
+                                   // that GUI has correct l18n
+
+      app.setApplicationName ("WSJT-X Reference UDP Message Aggregator Server");
+      app.setApplicationVersion ("1.0");
+
+      QObject::connect (&app, SIGNAL (lastWindowClosed ()), &app, SLOT (quit ()));
+
+      {
+        QFile file {":/qss/default.qss"};
+        if (!file.open (QFile::ReadOnly))
+          {
+            throw std::runtime_error {
+              QString {"failed to open \"" + file.fileName () + "\": " + file.errorString ()}
+              .toLocal8Bit ().constData ()};
+          }
+        app.setStyleSheet (file.readAll());
+      }
+
+      MessageAggregatorMainWindow window;
+      return app.exec ();
+    }
+  catch (std::exception const & e)
+    {
+      QMessageBox::critical (nullptr, app.applicationName (), e.what ());
+      std::cerr << "Error: " << e.what () << '\n';
+    }
+  catch (...)
+    {
+      QMessageBox::critical (nullptr, app.applicationName (), QObject::tr ("Unexpected error"));
+      std::cerr << "Unexpected error\n";
+    }
+  return -1;
+}
@@ -0,0 +1,48 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2013 Karsten Ahnert
+  Copyright 2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED
+
+#include <boost/numeric/odeint/algebra/fusion_algebra.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// specialization for fusion sequences
+template< class FusionSequence >
+struct algebra_dispatcher_sfinae< FusionSequence ,
+                           typename boost::enable_if<
+                               typename boost::fusion::traits::is_sequence< FusionSequence >::type >::type >
+{
+    typedef fusion_algebra algebra_type;
+};
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED
@@ -0,0 +1,27 @@
+subroutine getlags(nsps8,lag0,lag1,lag2)
+  if(nsps8.eq.864) then
+     lag1=39
+     lag2=291
+     lag0=123
+  else if(nsps8.eq.1920) then
+     lag1=70
+     lag2=184
+     lag0=108
+  else if(nsps8.eq.5120) then
+     lag1=84
+     lag2=129
+     lag0=99
+  else if(nsps8.eq.10368) then
+     lag1=91
+     lag2=112
+     lag0=98
+  else if(nsps8.eq.31500) then
+     lag1=93
+     lag2=102
+     lag0=96
+  else 
+     stop 'Error in getlags'
+  endif
+
+  return
+end subroutine getlags
@@ -0,0 +1,53 @@
+subroutine flat4(s,npts0,nflatten)
+
+! Flatten a spectrum for optimum display
+! Input:  s(npts)    Linear scale in power
+!         nflatten   If nflatten=0, convert to dB but do not flatten
+! Output: s(npts)    Flattened, with dB scale
+
+
+  implicit real*8 (a-h,o-z)
+  real*4 s(6827)
+  real*4 base
+  real*8 x(1000),y(1000),a(5)
+  data nseg/10/,npct/10/
+
+  npts=min(6827,npts0)
+  if(s(1).gt.1.e29) go to 900         !Boundary between Rx intervals: do nothing
+  do i=1,npts
+     s(i)=10.0*log10(s(i))            !Convert to dB scale
+  enddo
+
+  if(nflatten.gt.0) then
+     nterms=5
+     if(nflatten.eq.2) nterms=1
+     nlen=npts/nseg                   !Length of test segment
+     i0=npts/2                        !Midpoint
+     k=0
+     do n=1,nseg                      !Skip first segment, likely rolloff here
+        ib=n*nlen
+        ia=ib-nlen+1
+        if(n.eq.nseg) ib=npts
+        call pctile(s(ia),ib-ia+1,npct,base) !Find lowest npct of points
+        do i=ia,ib
+           if(s(i).le.base) then
+              if (k.lt.1000) k=k+1    !Save these "lower envelope" points
+              x(k)=i-i0
+              y(k)=s(i)
+           endif
+        enddo
+     enddo
+     kz=k
+     a=0.
+  
+     call polyfit(x,y,y,kz,nterms,0,a,chisqr)  !Fit a low-order polynomial
+
+     do i=1,npts
+        t=i-i0
+        yfit=a(1)+t*(a(2)+t*(a(3)+t*(a(4)+t*(a(5)))))
+        s(i)=s(i)-yfit                !Subtract the fitted baseline
+     enddo
+  endif
+
+900 return
+end subroutine flat4
@@ -0,0 +1,45 @@
+#!/bin/sh
+
+# Example of how an LDPC code can be encoded using using sparse,
+# dense, and mixed representations of the generator matrix.  The dense
+# and mixed representations are based on the same set of message bits
+# as the sparse method with minprod heuristic.  This allows the correctness 
+# of these methods to be checked by verifying that they all produce the same 
+# result when encoding random messages.  The results are also checked by 
+# 'verify'.
+#
+# A (400,200) LDPC code with 3 checks per bit is used for the test.
+
+set -e  # Stop if an error occurs
+set -v  # Echo commands as they are read
+
+make-ldpc ex-ldpc-encode.pchk 200 400 1 evenboth 3 
+
+make-gen  ex-ldpc-encode.pchk ex-ldpc-encode.genf sparse first
+make-gen  ex-ldpc-encode.pchk ex-ldpc-encode.genc sparse mincol
+make-gen  ex-ldpc-encode.pchk ex-ldpc-encode.genp sparse minprod
+make-gen  ex-ldpc-encode.pchk ex-ldpc-encode.gend dense ex-ldpc-encode.genp
+make-gen  ex-ldpc-encode.pchk ex-ldpc-encode.genm mixed ex-ldpc-encode.genp
+
+rand-src  ex-ldpc-encode.src 1 200x10
+
+encode    ex-ldpc-encode.pchk ex-ldpc-encode.genf ex-ldpc-encode.src \
+          ex-ldpc-encode.encf
+encode    ex-ldpc-encode.pchk ex-ldpc-encode.genc ex-ldpc-encode.src \
+          ex-ldpc-encode.encc
+encode    ex-ldpc-encode.pchk ex-ldpc-encode.genp ex-ldpc-encode.src \
+          ex-ldpc-encode.encp
+encode    ex-ldpc-encode.pchk ex-ldpc-encode.gend ex-ldpc-encode.src \
+          ex-ldpc-encode.encd
+encode    ex-ldpc-encode.pchk ex-ldpc-encode.genm ex-ldpc-encode.src \
+          ex-ldpc-encode.encm
+
+cmp ex-ldpc-encode.encp ex-ldpc-encode.encd
+cmp ex-ldpc-encode.encp ex-ldpc-encode.encm
+
+verify    ex-ldpc-encode.pchk ex-ldpc-encode.encf ex-ldpc-encode.genf \
+          ex-ldpc-encode.src
+verify    ex-ldpc-encode.pchk ex-ldpc-encode.encc ex-ldpc-encode.genc \
+          ex-ldpc-encode.src
+verify    ex-ldpc-encode.pchk ex-ldpc-encode.encp ex-ldpc-encode.genp \
+          ex-ldpc-encode.src
@@ -0,0 +1,181 @@
+/*=============================================================================
+    Copyright (c) 1998-2003 Joel de Guzman
+    http://spirit.sourceforge.net/
+
+    Use, modification and distribution is subject to the Boost Software
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+============================================================================*/
+#if !defined(BOOST_SPIRIT_SKIPPER_IPP)
+#define BOOST_SPIRIT_SKIPPER_IPP
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+    struct space_parser;
+    template <typename BaseT>
+    struct no_skipper_iteration_policy;
+
+    namespace impl
+    {
+        template <typename ST, typename ScannerT, typename BaseT>
+        inline void
+        skipper_skip(
+            ST const& s,
+            ScannerT const& scan,
+            skipper_iteration_policy<BaseT> const&)
+        {
+            typedef scanner_policies<
+                no_skipper_iteration_policy<
+                    BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
+                BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
+                BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
+            > policies_t;
+
+            scanner<BOOST_DEDUCED_TYPENAME ScannerT::iterator_t, policies_t>
+                scan2(scan.first, scan.last, policies_t(scan));
+            typedef typename ScannerT::iterator_t iterator_t;
+
+            for (;;)
+            {
+                iterator_t save = scan.first;
+                if (!s.parse(scan2))
+                {
+                    scan.first = save;
+                    break;
+                }
+            }
+        }
+
+        template <typename ST, typename ScannerT, typename BaseT>
+        inline void
+        skipper_skip(
+            ST const& s,
+            ScannerT const& scan,
+            no_skipper_iteration_policy<BaseT> const&)
+        {
+            for (;;)
+            {
+                typedef typename ScannerT::iterator_t iterator_t;
+                iterator_t save = scan.first;
+                if (!s.parse(scan))
+                {
+                    scan.first = save;
+                    break;
+                }
+            }
+        }
+
+        template <typename ST, typename ScannerT>
+        inline void
+        skipper_skip(
+            ST const& s,
+            ScannerT const& scan,
+            iteration_policy const&)
+        {
+            for (;;)
+            {
+                typedef typename ScannerT::iterator_t iterator_t;
+                iterator_t save = scan.first;
+                if (!s.parse(scan))
+                {
+                    scan.first = save;
+                    break;
+                }
+            }
+        }
+
+        template <typename SkipT>
+        struct phrase_parser
+        {
+            template <typename IteratorT, typename ParserT>
+            static parse_info<IteratorT>
+            parse(
+                IteratorT const&    first_,
+                IteratorT const&    last,
+                ParserT const&      p,
+                SkipT const&        skip)
+            {
+                typedef skip_parser_iteration_policy<SkipT> iter_policy_t;
+                typedef scanner_policies<iter_policy_t> scanner_policies_t;
+                typedef scanner<IteratorT, scanner_policies_t> scanner_t;
+
+                iter_policy_t iter_policy(skip);
+                scanner_policies_t policies(iter_policy);
+                IteratorT first = first_;
+                scanner_t scan(first, last, policies);
+                match<nil_t> hit = p.parse(scan);
+                return parse_info<IteratorT>(
+                    first, hit, hit && (first == last),
+                    hit.length());
+            }
+        };
+
+        template <>
+        struct phrase_parser<space_parser>
+        {
+            template <typename IteratorT, typename ParserT>
+            static parse_info<IteratorT>
+            parse(
+                IteratorT const&    first_,
+                IteratorT const&    last,
+                ParserT const&      p,
+                space_parser const&)
+            {
+                typedef skipper_iteration_policy<> iter_policy_t;
+                typedef scanner_policies<iter_policy_t> scanner_policies_t;
+                typedef scanner<IteratorT, scanner_policies_t> scanner_t;
+
+                IteratorT first = first_;
+                scanner_t scan(first, last);
+                match<nil_t> hit = p.parse(scan);
+                return parse_info<IteratorT>(
+                    first, hit, hit && (first == last),
+                    hit.length());
+            }
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  Free parse functions using the skippers
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename IteratorT, typename ParserT, typename SkipT>
+    inline parse_info<IteratorT>
+    parse(
+        IteratorT const&        first,
+        IteratorT const&        last,
+        parser<ParserT> const&  p,
+        parser<SkipT> const&    skip)
+    {
+        return impl::phrase_parser<SkipT>::
+            parse(first, last, p.derived(), skip.derived());
+    }
+    
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  Parse function for null terminated strings using the skippers
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename CharT, typename ParserT, typename SkipT>
+    inline parse_info<CharT const*>
+    parse(
+        CharT const*            str,
+        parser<ParserT> const&  p,
+        parser<SkipT> const&    skip)
+    {
+        CharT const* last = str;
+        while (*last)
+            last++;
+        return parse(str, last, p, skip);
+    }
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace boost::spirit
+
+#endif
+
@@ -0,0 +1,180 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2009, 2011 Helge Bahmann
+ * Copyright (c) 2009 Phil Endecott
+ * Copyright (c) 2013 Tim Blechmann
+ * Linux-specific code by Phil Endecott
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_linux_arm.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/detail/ops_cas_based.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+// Different ARM processors have different atomic instructions.  In particular,
+// architecture versions before v6 (which are still in widespread use, e.g. the
+// Intel/Marvell XScale chips like the one in the NSLU2) have only atomic swap.
+// On Linux the kernel provides some support that lets us abstract away from
+// these differences: it provides emulated CAS and barrier functions at special
+// addresses that are guaranteed not to be interrupted by the kernel.  Using
+// this facility is slightly slower than inline assembler would be, but much
+// faster than a system call.
+//
+// While this emulated CAS is "strong" in the sense that it does not fail
+// "spuriously" (i.e.: it never fails to perform the exchange when the value
+// found equals the value expected), it does not return the found value on
+// failure. To satisfy the atomic API, compare_exchange_{weak|strong} must
+// return the found value on failure, and we have to manually load this value
+// after the emulated CAS reports failure. This in turn introduces a race
+// between the CAS failing (due to the "wrong" value being found) and subsequently
+// loading (which might turn up the "right" value). From an application's
+// point of view this looks like "spurious failure", and therefore the
+// emulated CAS is only good enough to provide compare_exchange_weak
+// semantics.
+
+struct linux_arm_cas_base
+{
+    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
+
+    static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
+    {
+        typedef void (*kernel_dmb_t)(void);
+        ((kernel_dmb_t)0xffff0fa0)();
+    }
+};
+
+template< bool Signed >
+struct linux_arm_cas :
+    public linux_arm_cas_base
+{
+    typedef typename make_storage_type< 4u, Signed >::type storage_type;
+    typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before_store(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        while (true)
+        {
+            storage_type tmp = expected;
+            if (compare_exchange_weak(storage, tmp, desired, success_order, failure_order))
+                return true;
+            if (tmp != expected)
+            {
+                expected = tmp;
+                return false;
+            }
+        }
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        typedef storage_type (*kernel_cmpxchg32_t)(storage_type oldval, storage_type newval, volatile storage_type* ptr);
+
+        if (((kernel_cmpxchg32_t)0xffff0fc0)(expected, desired, &storage) == 0)
+        {
+            return true;
+        }
+        else
+        {
+            expected = storage;
+            return false;
+        }
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< cas_based_operations< cas_based_exchange< linux_arm_cas< Signed > > >, 1u, Signed >
+{
+};
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< cas_based_operations< cas_based_exchange< linux_arm_cas< Signed > > >, 2u, Signed >
+{
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public cas_based_operations< cas_based_exchange< linux_arm_cas< Signed > > >
+{
+};
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        linux_arm_cas_base::hardware_full_fence();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
@@ -0,0 +1,24 @@
+# /* Copyright (C) 2001
+#  * Housemarque Oy
+#  * http://www.housemarque.com
+#  *
+#  * Distributed under the Boost Software License, Version 1.0. (See
+#  * accompanying file LICENSE_1_0.txt or copy at
+#  * http://www.boost.org/LICENSE_1_0.txt)
+#  */
+#
+# /* Revised by Paul Mensonides (2002) */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_COMPARISON_HPP
+# define BOOST_PREPROCESSOR_COMPARISON_HPP
+#
+# include <boost/preprocessor/comparison/equal.hpp>
+# include <boost/preprocessor/comparison/greater.hpp>
+# include <boost/preprocessor/comparison/greater_equal.hpp>
+# include <boost/preprocessor/comparison/less.hpp>
+# include <boost/preprocessor/comparison/less_equal.hpp>
+# include <boost/preprocessor/comparison/not_equal.hpp>
+#
+# endif
@@ -0,0 +1,137 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  (C) Copyright Jens Maurer 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed.
+// Note that we define the headers to include using "header_name" not
+// <header_name> in order to prevent macro expansion within the header
+// name (for example "linux" is a macro on linux systems).
+
+#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
+// linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though?
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
+
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+// BSD:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp"
+
+#elif defined(sun) || defined(__sun)
+// solaris:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp"
+
+#elif defined(__sgi)
+// SGI Irix:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp"
+
+#elif defined(__hpux)
+// hp unix:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp"
+
+#elif defined(__CYGWIN__)
+// cygwin is not win32:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+// win32:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"
+
+#elif defined(__HAIKU__)
+// Haiku
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/haiku.hpp"
+
+#elif defined(__BEOS__)
+// BeOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"
+
+#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+// MacOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"
+
+#elif defined(__IBMCPP__) || defined(_AIX)
+// IBM
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"
+
+#elif defined(__amigaos__)
+// AmigaOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp"
+
+#elif defined(__QNXNTO__)
+// QNX:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp"
+
+#elif defined(__VXWORKS__)
+// vxWorks:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vxworks.hpp"
+
+#elif defined(__SYMBIAN32__) 
+// Symbian: 
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" 
+
+#elif defined(_CRAYC)
+// Cray:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cray.hpp" 
+
+#elif defined(__VMS) 
+// VMS:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 
+
+#elif defined(__CloudABI__)
+// Nuxi CloudABI:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cloudabi.hpp"
+#else
+
+#  if defined(unix) \
+      || defined(__unix) \
+      || defined(_XOPEN_SOURCE) \
+      || defined(_POSIX_SOURCE)
+
+   // generic unix platform:
+
+#  ifndef BOOST_HAS_UNISTD_H
+#     define BOOST_HAS_UNISTD_H
+#  endif
+
+#  include <boost/config/posix_features.hpp>
+
+#  endif
+
+#  if defined (BOOST_ASSERT_CONFIG)
+      // this must come last - generate an error if we don't
+      // recognise the platform:
+#     error "Unknown platform - please configure and report the results to boost.org"
+#  endif
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+#  include "boost/config/platform/linux.hpp"
+#  include "boost/config/platform/bsd.hpp"
+#  include "boost/config/platform/solaris.hpp"
+#  include "boost/config/platform/irix.hpp"
+#  include "boost/config/platform/hpux.hpp"
+#  include "boost/config/platform/cygwin.hpp"
+#  include "boost/config/platform/win32.hpp"
+#  include "boost/config/platform/beos.hpp"
+#  include "boost/config/platform/macos.hpp"
+#  include "boost/config/platform/aix.hpp"
+#  include "boost/config/platform/amigaos.hpp"
+#  include "boost/config/platform/qnxnto.hpp"
+#  include "boost/config/platform/vxworks.hpp"
+#  include "boost/config/platform/symbian.hpp" 
+#  include "boost/config/platform/cray.hpp" 
+#  include "boost/config/platform/vms.hpp" 
+#  include <boost/config/posix_features.hpp>
+
+
+
+#endif
+