Initial Commit

2018-02-08 21:28:33 -05:00
commit 678c1d3966
14352 changed files with 3176737 additions and 0 deletions
@@ -0,0 +1,472 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 2011-2013 Vicente J. Botet Escriba
+//
+//  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_THREAD_CONFIG_WEK01032003_HPP
+#define BOOST_THREAD_CONFIG_WEK01032003_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/thread/detail/platform.hpp>
+
+//#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
+// ATTRIBUTE_MAY_ALIAS
+
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+
+  // GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
+  // regard to violation of the strict aliasing rules.
+
+  #define BOOST_THREAD_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
+#else
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS
+#endif
+
+
+#if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
+#define BOOST_THREAD_ASSERT_PRECONDITION(EXPR, EX) \
+        if (EXPR) {} else boost::throw_exception(EX)
+#define BOOST_THREAD_VERIFY_PRECONDITION(EXPR, EX) \
+        if (EXPR) {} else boost::throw_exception(EX)
+#define BOOST_THREAD_THROW_ELSE_RETURN(EX, RET) \
+        boost::throw_exception(EX)
+#else
+#define BOOST_THREAD_ASSERT_PRECONDITION(EXPR, EX)
+#define BOOST_THREAD_VERIFY_PRECONDITION(EXPR, EX) \
+        (void)(EXPR)
+#define BOOST_THREAD_THROW_ELSE_RETURN(EX, RET) \
+        return (RET)
+#endif
+
+// This compiler doesn't support Boost.Chrono
+#if defined __IBMCPP__ && (__IBMCPP__ < 1100) \
+  && ! defined BOOST_THREAD_DONT_USE_CHRONO
+#define BOOST_THREAD_DONT_USE_CHRONO
+#if ! defined BOOST_THREAD_USES_DATETIME
+#define BOOST_THREAD_USES_DATETIME
+#endif
+#endif
+
+// This compiler doesn't support Boost.Move
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) \
+  && ! defined BOOST_THREAD_DONT_USE_MOVE
+#define BOOST_THREAD_DONT_USE_MOVE
+#endif
+
+// This compiler doesn't support Boost.Container Allocators files
+#if defined __SUNPRO_CC \
+  && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS
+#define BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS
+#endif
+
+#if defined _WIN32_WCE && _WIN32_WCE==0x501 \
+  && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS
+#define BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS
+#endif
+
+
+#if defined BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX || defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_THREAD_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_THREAD_NO_MAKE_LOCK_GUARD
+#define BOOST_THREAD_NO_MAKE_STRICT_LOCK
+#define BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK
+#endif
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#define BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS
+#define BOOST_THREAD_NO_SYNCHRONIZE
+#elif defined _MSC_VER && _MSC_VER <= 1600
+// C++ features supported by VC++ 10 (aka 2010)
+#define BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS
+#define BOOST_THREAD_NO_SYNCHRONIZE
+#endif
+
+/// BASIC_THREAD_ID
+#if ! defined BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID \
+ && ! defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
+#define BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
+#endif
+
+/// RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+//#if defined BOOST_NO_CXX11_RVALUE_REFERENCES || defined BOOST_MSVC
+#define BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+//#endif
+
+// Default version
+#if !defined BOOST_THREAD_VERSION
+#define BOOST_THREAD_VERSION 2
+#else
+#if BOOST_THREAD_VERSION!=2  && BOOST_THREAD_VERSION!=3 && BOOST_THREAD_VERSION!=4 && BOOST_THREAD_VERSION!=5
+#error "BOOST_THREAD_VERSION must be 2, 3, 4 or 5"
+#endif
+#endif
+
+// CHRONO
+// Uses Boost.Chrono by default if not stated the opposite defining BOOST_THREAD_DONT_USE_CHRONO
+#if ! defined BOOST_THREAD_DONT_USE_CHRONO \
+  && ! defined BOOST_THREAD_USES_CHRONO
+#define BOOST_THREAD_USES_CHRONO
+#endif
+
+#if ! defined BOOST_THREAD_DONT_USE_ATOMIC \
+  && ! defined BOOST_THREAD_USES_ATOMIC
+#define BOOST_THREAD_USES_ATOMIC
+//#define BOOST_THREAD_DONT_USE_ATOMIC
+#endif
+
+#if defined BOOST_THREAD_USES_ATOMIC
+// Andrey Semashev
+#define BOOST_THREAD_ONCE_ATOMIC
+#else
+//#elif ! defined BOOST_NO_CXX11_THREAD_LOCAL && ! defined BOOST_NO_THREAD_LOCAL && ! defined BOOST_THREAD_NO_UINT32_PSEUDO_ATOMIC
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html#Appendix
+#define BOOST_THREAD_ONCE_FAST_EPOCH
+#endif
+#if BOOST_THREAD_VERSION==2
+
+// PROVIDE_PROMISE_LAZY
+#if ! defined BOOST_THREAD_DONT_PROVIDE_PROMISE_LAZY \
+  && ! defined BOOST_THREAD_PROVIDES_PROMISE_LAZY
+#define BOOST_THREAD_PROVIDES_PROMISE_LAZY
+#endif
+
+// PROVIDE_THREAD_EQ
+#if ! defined BOOST_THREAD_DONT_PROVIDE_THREAD_EQ \
+  && ! defined BOOST_THREAD_PROVIDES_THREAD_EQ
+#define BOOST_THREAD_PROVIDES_THREAD_EQ
+#endif
+
+#endif
+
+#if BOOST_THREAD_VERSION>=3
+
+// ONCE_CXX11
+// fixme BOOST_THREAD_PROVIDES_ONCE_CXX11 doesn't works when thread.cpp is compiled BOOST_THREAD_VERSION 3
+#if ! defined BOOST_THREAD_DONT_PROVIDE_ONCE_CXX11 \
+ && ! defined BOOST_THREAD_PROVIDES_ONCE_CXX11
+#define BOOST_THREAD_DONT_PROVIDE_ONCE_CXX11
+#endif
+
+// THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE
+#if ! defined BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE \
+ && ! defined BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE
+#define BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE
+#endif
+
+// THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
+#if ! defined BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE \
+ && ! defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
+#define BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
+#endif
+
+// PROVIDE_FUTURE
+#if ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE \
+ && ! defined BOOST_THREAD_PROVIDES_FUTURE
+#define BOOST_THREAD_PROVIDES_FUTURE
+#endif
+
+// FUTURE_CTOR_ALLOCATORS
+#if ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS \
+ && ! defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
+#define BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
+#endif
+
+// SHARED_MUTEX_UPWARDS_CONVERSIONS
+#if ! defined BOOST_THREAD_DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSIONS \
+ && ! defined BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+#define BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+#endif
+
+// PROVIDE_EXPLICIT_LOCK_CONVERSION
+#if ! defined BOOST_THREAD_DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION \
+ && ! defined BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
+#define BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
+#endif
+
+// GENERIC_SHARED_MUTEX_ON_WIN
+#if ! defined BOOST_THREAD_DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN \
+ && ! defined BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
+#define BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
+#endif
+
+// USE_MOVE
+#if ! defined BOOST_THREAD_DONT_USE_MOVE \
+ && ! defined BOOST_THREAD_USES_MOVE
+#define BOOST_THREAD_USES_MOVE
+#endif
+
+#endif
+
+// deprecated since version 4
+#if BOOST_THREAD_VERSION < 4
+
+// NESTED_LOCKS
+#if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS
+#define BOOST_THREAD_PROVIDES_NESTED_LOCKS
+#endif
+
+// CONDITION
+#if ! defined BOOST_THREAD_PROVIDES_CONDITION \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_CONDITION
+#define BOOST_THREAD_PROVIDES_CONDITION
+#endif
+
+// USE_DATETIME
+#if ! defined BOOST_THREAD_DONT_USE_DATETIME \
+ && ! defined BOOST_THREAD_USES_DATETIME
+#define BOOST_THREAD_USES_DATETIME
+#endif
+#endif
+
+#if BOOST_THREAD_VERSION>=4
+
+// SIGNATURE_PACKAGED_TASK
+#if ! defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKAGED_TASK
+#define BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK
+#endif
+
+// VARIADIC_THREAD
+#if ! defined BOOST_THREAD_PROVIDES_VARIADIC_THREAD \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_VARIADIC_THREAD
+
+#if ! defined(BOOST_NO_SFINAE_EXPR) && \
+    ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+    ! defined(BOOST_NO_CXX11_DECLTYPE) && \
+    ! defined(BOOST_NO_CXX11_DECLTYPE_N3276) && \
+    ! defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES) && \
+    ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    ! defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#define BOOST_THREAD_PROVIDES_VARIADIC_THREAD
+#endif
+#endif
+
+#if ! defined BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_WHEN_ALL_WHEN_ANY
+
+#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+    ! defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#define BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY
+#endif
+#endif
+
+//    ! defined(BOOST_NO_SFINAE_EXPR) &&
+//    ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) &&
+//    ! defined(BOOST_NO_CXX11_AUTO) &&
+//    ! defined(BOOST_NO_CXX11_DECLTYPE) &&
+//    ! defined(BOOST_NO_CXX11_DECLTYPE_N3276) &&
+
+
+// MAKE_READY_AT_THREAD_EXIT
+#if ! defined BOOST_THREAD_PROVIDES_MAKE_READY_AT_THREAD_EXIT \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_MAKE_READY_AT_THREAD_EXIT
+
+//#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+#define BOOST_THREAD_PROVIDES_MAKE_READY_AT_THREAD_EXIT
+//#endif
+#endif
+
+// FUTURE_CONTINUATION
+#if ! defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CONTINUATION
+#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
+#endif
+
+#if ! defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_UNWRAP
+#define BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
+#endif
+
+// FUTURE_INVALID_AFTER_GET
+#if ! defined BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET
+#define BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+#endif
+
+// NESTED_LOCKS
+#if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS
+#define BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS
+#endif
+
+// CONDITION
+#if ! defined BOOST_THREAD_PROVIDES_CONDITION \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_CONDITION
+#define BOOST_THREAD_DONT_PROVIDE_CONDITION
+#endif
+
+#endif // BOOST_THREAD_VERSION>=4
+
+
+#if BOOST_THREAD_VERSION>=5
+//#define BOOST_THREAD_FUTURE_BLOCKING
+#else
+//#define BOOST_THREAD_FUTURE_BLOCKING
+#define BOOST_THREAD_ASYNC_FUTURE_WAITS
+#endif
+// INTERRUPTIONS
+#if ! defined BOOST_THREAD_PROVIDES_INTERRUPTIONS \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
+#define BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#endif
+
+// CORRELATIONS
+
+// EXPLICIT_LOCK_CONVERSION.
+#if defined BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
+#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION explicit
+#else
+#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION
+#endif
+
+// BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN is defined if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+#if defined BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS \
+&& ! defined BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
+#define BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
+#endif
+
+// For C++11 call_once interface the compiler MUST support constexpr.
+// Otherwise once_flag would be initialized during dynamic initialization stage, which is not thread-safe.
+#if defined(BOOST_THREAD_PROVIDES_ONCE_CXX11)
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+#undef BOOST_THREAD_PROVIDES_ONCE_CXX11
+#endif
+#endif
+
+#if defined(BOOST_THREAD_PLATFORM_WIN32) && defined BOOST_THREAD_DONT_USE_DATETIME
+#undef BOOST_THREAD_DONT_USE_DATETIME
+#define BOOST_THREAD_USES_DATETIME
+#endif
+
+#if defined(BOOST_THREAD_PLATFORM_WIN32) && defined BOOST_THREAD_DONT_USE_CHRONO
+#undef BOOST_THREAD_DONT_USE_CHRONO
+#define BOOST_THREAD_USES_CHRONO
+#endif
+
+// BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 defined by default up to Boost 1.55
+// BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0 defined by default up to Boost 1.55
+#if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0
+
+#if  ! defined BOOST_THREAD_PROVIDES_THREAD_EQ
+#define BOOST_THREAD_PROVIDES_THREAD_EQ
+#endif
+
+#endif
+
+
+//#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES || defined BOOST_THREAD_USES_MOVE
+#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_THREAD_FUTURE_USES_OPTIONAL
+#endif
+
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#  pragma warn -8008 // Condition always true/false
+#  pragma warn -8080 // Identifier declared but never used
+#  pragma warn -8057 // Parameter never used
+#  pragma warn -8066 // Unreachable code
+#endif
+
+#include <boost/thread/detail/platform.hpp>
+
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#else
+  #   if defined(BOOST_HAS_PTHREAD_DELAY_NP) || defined(BOOST_HAS_NANOSLEEP)
+  #     define BOOST_THREAD_SLEEP_FOR_IS_STEADY
+  #   endif
+#endif
+
+// provided for backwards compatibility, since this
+// macro was used for several releases by mistake.
+#if defined(BOOST_THREAD_DYN_DLL) && ! defined BOOST_THREAD_DYN_LINK
+# define BOOST_THREAD_DYN_LINK
+#endif
+
+// compatibility with the rest of Boost's auto-linking code:
+#if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
+# undef  BOOST_THREAD_USE_LIB
+# if !defined(BOOST_THREAD_USE_DLL)
+#  define BOOST_THREAD_USE_DLL
+# endif
+#endif
+
+#if defined(BOOST_THREAD_BUILD_DLL)   //Build dll
+#elif defined(BOOST_THREAD_BUILD_LIB) //Build lib
+#elif defined(BOOST_THREAD_USE_DLL)   //Use dll
+#elif defined(BOOST_THREAD_USE_LIB)   //Use lib
+#else //Use default
+#   if defined(BOOST_THREAD_PLATFORM_WIN32)
+#       if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN) \
+      || defined(__MINGW32__) || defined(MINGW32) || defined(BOOST_MINGW32)
+      //For compilers supporting auto-tss cleanup
+            //with Boost.Threads lib, use Boost.Threads lib
+#           define BOOST_THREAD_USE_LIB
+#       else
+            //For compilers not yet supporting auto-tss cleanup
+            //with Boost.Threads lib, use Boost.Threads dll
+#           define BOOST_THREAD_USE_DLL
+#       endif
+#   else
+#       define BOOST_THREAD_USE_LIB
+#   endif
+#endif
+
+#if defined(BOOST_HAS_DECLSPEC)
+#   if defined(BOOST_THREAD_BUILD_DLL) //Build dll
+#       define BOOST_THREAD_DECL BOOST_SYMBOL_EXPORT
+//#       define BOOST_THREAD_DECL __declspec(dllexport)
+
+#   elif defined(BOOST_THREAD_USE_DLL) //Use dll
+#       define BOOST_THREAD_DECL BOOST_SYMBOL_IMPORT
+//#       define BOOST_THREAD_DECL __declspec(dllimport)
+#   else
+#       define BOOST_THREAD_DECL
+#   endif
+#elif (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  define BOOST_THREAD_DECL BOOST_SYMBOL_VISIBLE
+
+#else
+#   define BOOST_THREAD_DECL
+#endif // BOOST_HAS_DECLSPEC
+
+//
+// Automatically link to the correct build variant where possible.
+//
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_THREAD_NO_LIB) && !defined(BOOST_THREAD_BUILD_DLL) && !defined(BOOST_THREAD_BUILD_LIB)
+//
+// Tell the autolink to link dynamically, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#if defined(BOOST_THREAD_USE_DLL)
+#   define BOOST_DYN_LINK
+#endif
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#if defined(BOOST_THREAD_LIB_NAME)
+#    define BOOST_LIB_NAME BOOST_THREAD_LIB_NAME
+#else
+#    define BOOST_LIB_NAME boost_thread
+#endif
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_THREAD_CONFIG_WEK1032003_HPP
+
+// Change Log:
+//   22 Jan 05 Roland Schwarz (speedsnail)
+//      Usage of BOOST_HAS_DECLSPEC macro.
+//      Default again is static lib usage.
+//      BOOST_DYN_LINK only defined when autolink included.
@@ -0,0 +1,110 @@
+//---------------------------------------------------------------------------//
+// Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.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
+//
+// See http://boostorg.github.com/compute for more information.
+//---------------------------------------------------------------------------//
+
+#ifndef BOOST_COMPUTE_ALGORITHM_DETAIL_REDUCE_ON_CPU_HPP
+#define BOOST_COMPUTE_ALGORITHM_DETAIL_REDUCE_ON_CPU_HPP
+
+#include <algorithm>
+
+#include <boost/compute/buffer.hpp>
+#include <boost/compute/command_queue.hpp>
+#include <boost/compute/detail/meta_kernel.hpp>
+#include <boost/compute/detail/iterator_range_size.hpp>
+#include <boost/compute/detail/parameter_cache.hpp>
+#include <boost/compute/iterator/buffer_iterator.hpp>
+#include <boost/compute/type_traits/result_of.hpp>
+#include <boost/compute/algorithm/detail/serial_reduce.hpp>
+
+namespace boost {
+namespace compute {
+namespace detail {
+
+template<class InputIterator, class OutputIterator, class BinaryFunction>
+inline void reduce_on_cpu(InputIterator first,
+                          InputIterator last,
+                          OutputIterator result,
+                          BinaryFunction function,
+                          command_queue &queue)
+{
+    typedef typename
+        std::iterator_traits<InputIterator>::value_type T;
+    typedef typename
+        ::boost::compute::result_of<BinaryFunction(T, T)>::type result_type;
+
+    const device &device = queue.get_device();
+    const uint_ compute_units = queue.get_device().compute_units();
+
+    boost::shared_ptr<parameter_cache> parameters =
+        detail::parameter_cache::get_global_cache(device);
+
+    std::string cache_key =
+        "__boost_reduce_cpu_" + boost::lexical_cast<std::string>(sizeof(T));
+
+    // for inputs smaller than serial_reduce_threshold
+    // serial_reduce algorithm is used
+    uint_ serial_reduce_threshold =
+        parameters->get(cache_key, "serial_reduce_threshold", 16384 * sizeof(T));
+    serial_reduce_threshold =
+        (std::max)(serial_reduce_threshold, uint_(compute_units));
+
+    const context &context = queue.get_context();
+    size_t count = detail::iterator_range_size(first, last);
+    if(count == 0){
+        return;
+    }
+    else if(count < serial_reduce_threshold) {
+        return serial_reduce(first, last, result, function, queue);
+    }
+
+    meta_kernel k("reduce_on_cpu");
+    buffer output(context, sizeof(result_type) * compute_units);
+
+    size_t count_arg = k.add_arg<uint_>("count");
+    size_t output_arg =
+        k.add_arg<result_type *>(memory_object::global_memory, "output");
+
+    k <<
+        "uint block = " <<
+            "(uint)ceil(((float)count)/get_global_size(0));\n" <<
+        "uint index = get_global_id(0) * block;\n" <<
+        "uint end = min(count, index + block);\n" <<
+
+        k.decl<result_type>("result") << " = " << first[k.var<uint_>("index")] << ";\n" <<
+        "index++;\n" <<
+        "while(index < end){\n" <<
+             "result = " << function(k.var<T>("result"),
+                                     first[k.var<uint_>("index")]) << ";\n" <<
+             "index++;\n" <<
+        "}\n" <<
+        "output[get_global_id(0)] = result;\n";
+
+    size_t global_work_size = compute_units;
+    kernel kernel = k.compile(context);
+
+    // reduction to global_work_size elements
+    kernel.set_arg(count_arg, static_cast<uint_>(count));
+    kernel.set_arg(output_arg, output);
+    queue.enqueue_1d_range_kernel(kernel, 0, global_work_size, 0);
+
+    // final reduction
+    reduce_on_cpu(
+        make_buffer_iterator<result_type>(output),
+        make_buffer_iterator<result_type>(output, global_work_size),
+        result,
+        function,
+        queue
+    );
+}
+
+} // end detail namespace
+} // end compute namespace
+} // end boost namespace
+
+#endif // BOOST_COMPUTE_ALGORITHM_DETAIL_REDUCE_ON_CPU_HPP
@@ -0,0 +1,94 @@
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+
+// Preprocessed version of "boost/mpl/greater.hpp" header
+// -- DO NOT modify by hand!
+
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct greater_impl
+    : if_c<
+          ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1)
+              > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2)
+            )
+
+        , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+/// for Digital Mars C++/compilers with no CTPS/TTP support
+template<> struct greater_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        BOOST_STATIC_CONSTANT(int, value  = 0);
+    };
+};
+
+template<> struct greater_impl< na,integral_c_tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        BOOST_STATIC_CONSTANT(int, value  = 0);
+    };
+};
+
+template<> struct greater_impl< integral_c_tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        BOOST_STATIC_CONSTANT(int, value  = 0);
+    };
+};
+
+template< typename T > struct greater_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(N1)
+    , typename BOOST_MPL_AUX_NA_PARAM(N2)
+    >
+struct greater
+
+    : greater_impl<
+          typename greater_tag<N1>::type
+        , typename greater_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2))
+
+};
+
+BOOST_MPL_AUX_NA_SPEC2(2, 2, greater)
+
+}}
+
+namespace boost { namespace mpl {
+
+template<>
+struct greater_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) >
+    {
+    };
+};
+
+}}
@@ -0,0 +1,77 @@
+
+#ifndef BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED
+#define BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/aux_/is_msvc_eti_arg.hpp>
+#include <boost/mpl/aux_/config/eti.hpp>
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+#if defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG)
+
+template< bool > struct msvc_eti_base_impl
+{
+    template< typename T > struct result_
+        : T
+    {
+        typedef T type;
+    };
+};
+
+template<> struct msvc_eti_base_impl<true>
+{
+    template< typename T > struct result_
+    {
+        typedef result_ type;
+        typedef result_ first;
+        typedef result_ second;
+        typedef result_ tag;
+        enum { value = 0 };
+    };
+};
+
+template< typename T > struct msvc_eti_base
+    : msvc_eti_base_impl< is_msvc_eti_arg<T>::value >
+        ::template result_<T>
+{
+};
+
+#else // !BOOST_MPL_CFG_MSVC_70_ETI_BUG
+
+template< typename T > struct msvc_eti_base
+    : T
+{
+#if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304))
+    msvc_eti_base();
+#endif
+    typedef T type;
+};
+
+#endif 
+
+template<> struct msvc_eti_base<int>
+{
+    typedef msvc_eti_base type;
+    typedef msvc_eti_base first;
+    typedef msvc_eti_base second;
+    typedef msvc_eti_base tag;
+    enum { value = 0 };
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED
@@ -0,0 +1,180 @@
+/* boost random/student_t_distribution.hpp header file
+ *
+ * Copyright Steven Watanabe 2011
+ * 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 including documentation.
+ *
+ * $Id$
+ */
+
+#ifndef BOOST_RANDOM_STUDENT_T_DISTRIBUTION_HPP
+#define BOOST_RANDOM_STUDENT_T_DISTRIBUTION_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <iosfwd>
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/chi_squared_distribution.hpp>
+#include <boost/random/normal_distribution.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * The Student t distribution is a real valued distribution with one
+ * parameter n, the number of degrees of freedom.
+ *
+ * It has \f$\displaystyle p(x) =
+ *   \frac{1}{\sqrt{n\pi}}
+ *   \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
+ *   \left(1+\frac{x^2}{n}\right)^{-(n+1)/2}
+ * \f$.
+ */
+template<class RealType = double>
+class student_t_distribution {
+public:
+    typedef RealType result_type;
+    typedef RealType input_type;
+
+    class param_type {
+    public:
+        typedef student_t_distribution distribution_type;
+
+        /**
+         * Constructs a @c param_type with "n" degrees of freedom.
+         *
+         * Requires: n > 0
+         */
+        explicit param_type(RealType n_arg = RealType(1.0))
+          : _n(n_arg)
+        {}
+
+        /** Returns the number of degrees of freedom of the distribution. */
+        RealType n() const { return _n; }
+
+        /** Writes a @c param_type to a @c std::ostream. */
+        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+        { os << parm._n; return os; }
+
+        /** Reads a @c param_type from a @c std::istream. */
+        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+        { is >> parm._n; return is; }
+
+        /** Returns true if the two sets of parameters are the same. */
+        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        { return lhs._n == rhs._n; }
+        
+        /** Returns true if the two sets of parameters are the different. */
+        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+    private:
+        RealType _n;
+    };
+
+    /**
+     * Constructs an @c student_t_distribution with "n" degrees of freedom.
+     *
+     * Requires: n > 0
+     */
+    explicit student_t_distribution(RealType n_arg = RealType(1.0))
+      : _normal(), _chi_squared(n_arg)
+    {}
+    /** Constructs an @c student_t_distribution from its parameters. */
+    explicit student_t_distribution(const param_type& parm)
+      : _normal(), _chi_squared(parm.n())
+    {}
+
+    /**
+     * Returns a random variate distributed according to the
+     * Student t distribution.
+     */
+    template<class URNG>
+    RealType operator()(URNG& urng)
+    {
+        using std::sqrt;
+        return _normal(urng) / sqrt(_chi_squared(urng) / n());
+    }
+
+    /**
+     * Returns a random variate distributed accordint to the Student
+     * t distribution with parameters specified by @c param.
+     */
+    template<class URNG>
+    RealType operator()(URNG& urng, const param_type& parm) const
+    {
+        return student_t_distribution(parm)(urng);
+    }
+
+    /** Returns the number of degrees of freedom. */
+    RealType n() const { return _chi_squared.n(); }
+
+    /** Returns the smallest value that the distribution can produce. */
+    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    { return -std::numeric_limits<RealType>::infinity(); }
+    /** Returns the largest value that the distribution can produce. */
+    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    { return std::numeric_limits<RealType>::infinity(); }
+
+    /** Returns the parameters of the distribution. */
+    param_type param() const { return param_type(n()); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm)
+    {
+        typedef chi_squared_distribution<RealType> chi_squared_type;
+        typename chi_squared_type::param_type chi_squared_param(parm.n());
+        _chi_squared.param(chi_squared_param);
+    }
+
+    /**
+     * Effects: Subsequent uses of the distribution do not depend
+     * on values produced by any engine prior to invoking reset.
+     */
+    void reset()
+    {
+        _normal.reset();
+        _chi_squared.reset();
+    }
+
+    /** Writes a @c student_t_distribution to a @c std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, student_t_distribution, td)
+    {
+        os << td.param();
+        return os;
+    }
+
+    /** Reads a @c student_t_distribution from a @c std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, student_t_distribution, td)
+    {
+        param_type parm;
+        if(is >> parm) {
+            td.param(parm);
+        }
+        return is;
+    }
+
+    /**
+     * Returns true if the two instances of @c student_t_distribution will
+     * return identical sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(student_t_distribution, lhs, rhs)
+    { return lhs._normal == rhs._normal && lhs._chi_squared == rhs._chi_squared; }
+    
+    /**
+     * Returns true if the two instances of @c student_t_distribution will
+     * return different sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(student_t_distribution)
+
+private:
+    normal_distribution<RealType> _normal;
+    chi_squared_distribution<RealType> _chi_squared;
+};
+
+} // namespace random
+} // namespace boost
+
+#endif // BOOST_RANDOM_STUDENT_T_DISTRIBUTION_HPP
@@ -0,0 +1,14 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+#if !defined(FUSION_INCLUDE_MPL)
+#define FUSION_INCLUDE_MPL
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/mpl.hpp>
+
+#endif
@@ -0,0 +1,100 @@
+#include "logbook.h"
+#include <QDebug>
+#include <QFontMetrics>
+#include <QStandardPaths>
+#include <QDir>
+
+namespace
+{
+  auto logFileName = "wsjtx_log.adi";
+  auto countryFileName = "cty.dat";
+}
+
+void LogBook::init()
+{
+  QDir dataPath {QStandardPaths::writableLocation (QStandardPaths::DataLocation)};
+  QString countryDataFilename;
+  if (dataPath.exists (countryFileName))
+    {
+      // User override
+      countryDataFilename = dataPath.absoluteFilePath (countryFileName);
+    }
+  else
+    {
+      countryDataFilename = QString {":/"} + countryFileName;
+    }
+
+  _countries.init(countryDataFilename);
+  _countries.load();
+
+  _worked.init(_countries.getCountryNames());
+
+  _log.init(dataPath.absoluteFilePath (logFileName));
+  _log.load();
+
+  _setAlreadyWorkedFromLog();
+
+  /*
+    int QSOcount = _log.getCount();
+    int count = _worked.getWorkedCount();
+    qDebug() << QSOcount << "QSOs and" << count << "countries worked in file" << logFilename;
+  */
+
+  //    QString call = "ok1ct";
+  //    QString countryName;
+  //    bool callWorkedBefore,countryWorkedBefore;
+  //    match(/*in*/call, /*out*/ countryName,callWorkedBefore,countryWorkedBefore);
+  //    qDebug() << countryName;
+
+}
+
+
+void LogBook::_setAlreadyWorkedFromLog()
+{
+  QList<QString> calls = _log.getCallList();
+  QString c;
+  foreach(c,calls)
+    {
+      QString countryName = _countries.find(c);
+      if (countryName.length() > 0)
+        {
+          _worked.setAsWorked(countryName);
+          //qDebug() << countryName << " worked " << c;
+        }
+    }
+}
+
+void LogBook::match(/*in*/const QString call,
+                    /*out*/ QString &countryName,
+                    bool &callWorkedBefore,
+                    bool &countryWorkedBefore) const
+{
+  if (call.length() > 0)
+    {
+      QString currentMode = "JT9"; // JT65 == JT9 in ADIF::match()
+      QString currentBand = "";  // match any band
+      callWorkedBefore = _log.match(call,currentBand,currentMode);
+      countryName = _countries.find(call);
+
+      if (countryName.length() > 0)  //  country was found
+        countryWorkedBefore = _worked.getHasWorked(countryName);
+      else
+        {
+          countryName = "where?"; //error: prefix not found
+          countryWorkedBefore = false;
+        }
+    }
+  //qDebug() << "Logbook:" << call << ":" << countryName << "Cty B4:" << countryWorkedBefore << "call B4:" << callWorkedBefore;
+}
+
+void LogBook::addAsWorked(const QString call, const QString band, const QString mode, const QString date)
+{
+  //qDebug() << "adding " << call << " as worked";
+  _log.add(call,band,mode,date);
+  QString countryName = _countries.find(call);
+  if (countryName.length() > 0)
+    _worked.setAsWorked(countryName);
+}
+
+
+
@@ -0,0 +1,13 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+#if !defined(FUSION_INCLUDE_FRONT)
+#define FUSION_INCLUDE_FRONT
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+
+#endif
@@ -0,0 +1,65 @@
+// (C) Copyright Michael Glassford 2004.
+// 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)
+
+#if !defined(BOOST_TLS_HOOKS_HPP)
+#define BOOST_TLS_HOOKS_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS)
+
+namespace boost
+{
+    BOOST_THREAD_DECL void __cdecl on_process_enter(void);
+        //Function to be called when the exe or dll
+            //that uses Boost.Threads first starts
+            //or is first loaded.
+        //Should be called only before the first call to
+            //on_thread_enter().
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //May be omitted; may be called multiple times.
+
+    BOOST_THREAD_DECL void __cdecl on_process_exit(void);
+        //Function to be called when the exe or dll
+            //that uses Boost.Threads first starts
+            //or is first loaded.
+        //Should be called only after the last call to
+            //on_exit_thread().
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //Must not be omitted; may be called multiple times.
+
+    BOOST_THREAD_DECL void __cdecl on_thread_enter(void);
+        //Function to be called just after a thread starts
+            //in an exe or dll that uses Boost.Threads.
+        //Must be called in the context of the thread
+            //that is starting.
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //May be omitted; may be called multiple times.
+
+    BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
+        //Function to be called just be fore a thread ends
+            //in an exe or dll that uses Boost.Threads.
+        //Must be called in the context of the thread
+            //that is ending.
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //Must not be omitted; may be called multiple times.
+    
+    void tss_cleanup_implemented();
+        //Dummy function used both to detect whether tss cleanup
+            //cleanup has been implemented and to force
+            //it to be linked into the Boost.Threads library.
+}
+
+#endif //defined(BOOST_HAS_WINTHREADS)
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif //!defined(BOOST_TLS_HOOKS_HPP)
@@ -0,0 +1,104 @@
+=== AP Decoding
+
+The _WSJT-X_ decoders for QRA64 and FT8 include optional procedures
+that use naturally accumulating information during a minimal QSO.
+This _a priori_ (AP) information increases sensitivity of the decoder
+by up to 4 dB, at the cost of a slightly higher rate of false decodes.
+
+For example: when you decide to answer a CQ, you already know your own
+callsign and that of your potential QSO partner.  The software
+therefore "`knows`" what to expect for 57 of the 72 message bits (28
+bits for each of two callsigns, 1 bit for message type) in the next
+received message.  The decoder's task can thus be reduced to
+determining the remaining 15 bits of the message and ensuring that the
+resulting solution is reliable.
+
+AP decoding starts by setting AP bits to the hypothesized values, as
+if they had been received correctly.  We then determine whether the
+remaining message and parity bits are consistent with the hypothesized
+AP bits, with a specified level of confidence.  Successful AP decodes
+are labeled with an end-of-line indicator of the form `aP`, where `P`
+is one of the single-digit AP decoding types listed in Table 1.  For
+example, `a2` indicates that the successful decode used MyCall as
+hypothetically known information.
+
+[[AP_INFO_TABLE]]
+.AP information types
+[width="35%",cols="h10,<m20",frame=topbot,options="header"]
+|===============================================
+|P | Message components
+|1 | CQ   &#160; &#160;   ?   &#160; &#160;   ? 
+|2 | MyCall &#160; &#160; ?   &#160; &#160;   ? 
+|3 | MyCall DxCall &#160; &#160;  ? 
+|4 | MyCall DxCall RRR
+|5 | MyCall DxCall 73
+|6 | MyCall DxCall RR73
+|===============================================
+
+If a codeword is found that is judged to have high (but not
+overwhelmingly high) probability of being correct, a `?` character is
+appended when the decoded message is displayed.  To avoid misleading
+spots of occasional false decodes, messages so marked are not
+forwarded to {pskreporter}.
+
+Table 2 lists the six possible QSO states that are tracked by the
+_WSJT-X_ auto-sequencer, along with the type of AP decoding that would
+be attempted in each state.
+
+[[AP_DECODING_TYPES_TABLE]]
+.AP decoding types for each QSO state
+[width="35%",cols="h10,<m20",frame=topbot,options="header"]
+|===========================================
+|State        |AP type
+|CALLING      |   1, 2
+|REPLYING     |   2, 3
+|REPORT       |   2, 3
+|ROGER_REPORT |   3, 4, 5, 6
+|ROGERS       |   3, 4, 5, 6
+|SIGNOFF      |   3, 1, 2
+|===========================================
+
+
+=== Decoded Lines
+
+Displayed information accompanying decoded messages generally includes UTC,
+signal-to-noise ratio in dB, time offset DT in seconds, and
+audio frequency in Hz.  Some modes include additional information such
+as frequency offset from nominal (DF), frequency drift (Drift or F1),
+or distance (km or mi).
+
+There may also be some cryptic characters with special meanings
+summarized in the following Table:
+
+[[DECODED_LINES_TABLE]]
+.Notations used on decoded text lines
+[width="50%",cols="h,3*^",frame=topbot,options="header"]
+|===========================================
+|Mode    |Mode character|Sync character|End of line information
+|FT8     | ~            |      | ? &#160; aP
+|JT4     | $            | *, # | f, fN, dNC
+|JT9     | @            |      |
+|JT65    | #            |      |
+|JT65 VHF| #            | *, # | f, fN, dNC
+|QRA64   | :            | *    | R
+|ISCAT   |              | *    | M  N  C  T
+|MSK144  | &            |      | N  H  E
+|===========================================
+Sync character::
+ `*` - Normal sync +
+ `#` - Alternate sync
+
+End of line information::
+ `?` - Decoded with lower confidence +
+ `a` - Decoded with aid of some a priori (AP) information +
+ `C` - Confidence indicator [ISCAT and Deep Search; (0-9,*)] +
+ `d` - Deep Search algorithm +
+ `E` - Size of MSK eye diagram opening - if negative, the eye is closed + 
+ `f` - Franke-Taylor or Fano algorithm +
+ `H` - Number of bit errors corrected +
+ `M` - Message length (characters) +
+ `N` - Number of Rx intervals or frames averaged +
+ `P` - Number indicating type of AP information (Table 1, above) +
+ `R` - Return code from QRA64 decoder +
+ `T` - Length of analyzed region (s)
+
@@ -0,0 +1,30 @@
+
+//  Copyright (c) 2014 Agustin Berge
+//
+//  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/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_IS_FINAL_HPP_INCLUDED
+#define BOOST_TT_IS_FINAL_HPP_INCLUDED
+
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#ifdef BOOST_IS_FINAL
+#include <boost/type_traits/remove_cv.hpp>
+#endif
+
+namespace boost {
+
+#ifdef BOOST_IS_FINAL
+template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(typename remove_cv<T>::type)> {};
+#else
+template <class T> struct is_final : public integral_constant<bool, false> {};
+#endif
+
+} // namespace boost
+
+#endif // BOOST_TT_IS_FINAL_HPP_INCLUDED
@@ -0,0 +1,61 @@
+/*=============================================================================
+    Copyright (c) 2001-2013 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(BOOST_FUSION_MAP_DETAIL_AT_IMPL_02042013_0821)
+#define BOOST_FUSION_MAP_DETAIL_AT_IMPL_02042013_0821
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+#include <boost/utility/declval.hpp>
+
+namespace boost { namespace fusion
+{
+    struct map_tag;
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl;
+
+        template <>
+        struct at_impl<map_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply
+            {
+                typedef mpl::int_<N::value> index;
+                typedef
+                    decltype(boost::declval<Sequence>().get(index()))
+                type;
+
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+                static type
+                call(Sequence& m)
+                {
+                    return m.get(index());
+                }
+            };
+
+            template <typename Sequence, typename N>
+            struct apply<Sequence const, N>
+            {
+                typedef mpl::int_<N::value> index;
+                typedef
+                    decltype(boost::declval<Sequence const>().get(index()))
+                type;
+
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+                static type
+                call(Sequence const& m)
+                {
+                    return m.get(index());
+                }
+            };
+        };
+    }
+}}
+
+#endif
@@ -0,0 +1,556 @@
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+
+// Preprocessed version of "boost/mpl/vector.hpp" header
+// -- DO NOT modify by hand!
+
+namespace boost { namespace mpl {
+
+namespace aux {
+template< int N >
+struct vector_chooser;
+
+}
+
+namespace aux {
+
+template<>
+struct vector_chooser<0>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef vector0<
+             
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<1>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector1<
+              T0
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<2>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector2<
+              T0, T1
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<3>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector3<
+              T0, T1, T2
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<4>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector4<
+              T0, T1, T2, T3
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<5>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector5<
+              T0, T1, T2, T3, T4
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<6>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector6<
+              T0, T1, T2, T3, T4, T5
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<7>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector7<
+              T0, T1, T2, T3, T4, T5, T6
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<8>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector8<
+              T0, T1, T2, T3, T4, T5, T6, T7
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<9>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector9<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<10>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector10<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<11>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector11<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<12>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector12<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<13>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector13<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<14>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector14<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<15>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector15<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<16>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector16<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<17>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector17<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<18>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector18<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<19>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector19<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template<>
+struct vector_chooser<20>
+{
+    template<
+          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 T19
+        >
+    struct result_
+    {
+        typedef typename vector20<
+              T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19
+            >::type type;
+
+    };
+};
+
+} // namespace aux
+
+namespace aux {
+
+template< typename T >
+struct is_vector_arg
+{
+    BOOST_STATIC_CONSTANT(bool, value  = true);
+};
+
+template<>
+struct is_vector_arg<na>
+{
+    BOOST_STATIC_CONSTANT(bool, value  = false);
+};
+
+template<
+      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 T19, typename T20
+    >
+struct vector_count_args
+{
+    BOOST_STATIC_CONSTANT(int, value =
+          is_vector_arg<T1>::value + is_vector_arg<T2>::value 
+        + is_vector_arg<T3>::value + is_vector_arg<T4>::value 
+        + is_vector_arg<T5>::value + is_vector_arg<T6>::value 
+        + is_vector_arg<T7>::value + is_vector_arg<T8>::value 
+        + is_vector_arg<T9>::value + is_vector_arg<T10>::value 
+        + is_vector_arg<T11>::value + is_vector_arg<T12>::value 
+        + is_vector_arg<T13>::value + is_vector_arg<T14>::value 
+        + is_vector_arg<T15>::value + is_vector_arg<T16>::value 
+        + is_vector_arg<T17>::value + is_vector_arg<T18>::value 
+        + is_vector_arg<T19>::value + is_vector_arg<T20>::value
+        );
+
+};
+
+template<
+      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 T19
+    >
+struct vector_impl
+{
+    typedef aux::vector_count_args<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19
+        > arg_num_;
+
+    typedef typename aux::vector_chooser< arg_num_::value >
+        ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
+};
+
+} // namespace aux
+
+template<
+      typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
+    , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
+    , typename T12 = na, typename T13 = na, typename T14 = na
+    , typename T15 = na, typename T16 = na, typename T17 = na
+    , typename T18 = na, typename T19 = na
+    >
+struct vector
+    : aux::vector_impl<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19
+        >::type
+{
+    typedef typename aux::vector_impl<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19
+        >::type type;
+};
+
+}}
+
@@ -0,0 +1,68 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen, Neil Groves 2006. 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_ADAPTOR_COPIED_HPP
+#define BOOST_RANGE_ADAPTOR_COPIED_HPP
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/adaptor/sliced.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/concepts.hpp>
+
+namespace boost
+{
+    namespace adaptors
+    {
+        struct copied
+        {
+            copied(std::size_t t_, std::size_t u_)
+                : t(t_), u(u_) {}
+
+            std::size_t t;
+            std::size_t u;
+        };
+
+        template<class CopyableRandomAccessRange>
+        inline CopyableRandomAccessRange
+        operator|(const CopyableRandomAccessRange& r, const copied& f)
+        {
+            BOOST_RANGE_CONCEPT_ASSERT((
+                RandomAccessRangeConcept<const CopyableRandomAccessRange>));
+
+            iterator_range<
+                BOOST_DEDUCED_TYPENAME range_iterator<
+                    const CopyableRandomAccessRange
+                >::type
+            > temp(adaptors::slice(r, f.t, f.u));
+
+            return CopyableRandomAccessRange(temp.begin(), temp.end());
+        }
+
+        template<class CopyableRandomAccessRange>
+        inline CopyableRandomAccessRange
+        copy(const CopyableRandomAccessRange& rng, std::size_t t, std::size_t u)
+        {
+            BOOST_RANGE_CONCEPT_ASSERT((
+                RandomAccessRangeConcept<const CopyableRandomAccessRange>));
+
+            iterator_range<
+                BOOST_DEDUCED_TYPENAME range_iterator<
+                    const CopyableRandomAccessRange
+                >::type
+            > temp(adaptors::slice(rng, t, u));
+
+            return CopyableRandomAccessRange( temp.begin(), temp.end() );
+        }
+    } // 'adaptors'
+
+}
+
+#endif // include guard
@@ -0,0 +1,33 @@
+//==============================================================================
+//         Copyright 2014          LASMEA UMR 6602 CNRS/Univ. Clermont II
+//         Copyright 2014          LRI    UMR 8623 CNRS/Univ Paris Sud XI
+//         Copyright 2014          MetaScale SAS
+//
+//          Distributed under the Boost Software License, Version 1.0.
+//                 See accompanying file LICENSE.txt or copy at
+//                     http://www.boost.org/LICENSE_1_0.txt
+//==============================================================================
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_COPY_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_COPY_HPP_INCLUDED
+
+#include <nt2/core/container/table/table.hpp>
+
+#include <boost/numeric/odeint/util/copy.hpp>
+
+namespace boost { namespace numeric { namespace odeint {
+
+template<typename T, typename S>
+struct copy_impl< nt2::container::table<T,S>
+                , nt2::container::table<T,S>
+                >
+{
+  static void copy ( const nt2::container::table<T,S> &v1
+                   , nt2::container::table<T,S> &v2
+                   )
+  {
+    v2 = v1;
+  }
+};
+} } }
+
+#endif
@@ -0,0 +1,206 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2013 John Maddock. 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_
+
+#ifndef BOOST_MP_CPP_INT_LITERALS_HPP
+#define BOOST_MP_CPP_INT_LITERALS_HPP
+
+#include <boost/multiprecision/cpp_int/cpp_int_config.hpp>
+
+namespace boost{ namespace multiprecision{
+
+namespace literals{ namespace detail{
+
+template <char> struct hex_value;
+template <> struct hex_value<'0'> { static constexpr limb_type value = 0; };
+template <> struct hex_value<'1'> { static constexpr limb_type value = 1; };
+template <> struct hex_value<'2'> { static constexpr limb_type value = 2; };
+template <> struct hex_value<'3'> { static constexpr limb_type value = 3; };
+template <> struct hex_value<'4'> { static constexpr limb_type value = 4; };
+template <> struct hex_value<'5'> { static constexpr limb_type value = 5; };
+template <> struct hex_value<'6'> { static constexpr limb_type value = 6; };
+template <> struct hex_value<'7'> { static constexpr limb_type value = 7; };
+template <> struct hex_value<'8'> { static constexpr limb_type value = 8; };
+template <> struct hex_value<'9'> { static constexpr limb_type value = 9; };
+template <> struct hex_value<'a'> { static constexpr limb_type value = 10; };
+template <> struct hex_value<'b'> { static constexpr limb_type value = 11; };
+template <> struct hex_value<'c'> { static constexpr limb_type value = 12; };
+template <> struct hex_value<'d'> { static constexpr limb_type value = 13; };
+template <> struct hex_value<'e'> { static constexpr limb_type value = 14; };
+template <> struct hex_value<'f'> { static constexpr limb_type value = 15; };
+template <> struct hex_value<'A'> { static constexpr limb_type value = 10; };
+template <> struct hex_value<'B'> { static constexpr limb_type value = 11; };
+template <> struct hex_value<'C'> { static constexpr limb_type value = 12; };
+template <> struct hex_value<'D'> { static constexpr limb_type value = 13; };
+template <> struct hex_value<'E'> { static constexpr limb_type value = 14; };
+template <> struct hex_value<'F'> { static constexpr limb_type value = 15; };
+
+template <class Pack, limb_type value>
+struct combine_value_to_pack;
+template <limb_type first, limb_type...ARGS, limb_type value>
+struct combine_value_to_pack<value_pack<first, ARGS...>, value>
+{
+   typedef value_pack<first | value, ARGS...> type;
+};
+
+template <char NextChar, char...CHARS>
+struct pack_values
+{
+   static constexpr unsigned chars_per_limb = sizeof(limb_type) * CHAR_BIT / 4;
+   static constexpr unsigned shift = ((sizeof...(CHARS)) % chars_per_limb) * 4;
+   static constexpr limb_type value_to_add = shift ? hex_value<NextChar>::value << shift : hex_value<NextChar>::value;
+
+   typedef typename pack_values<CHARS...>::type recursive_packed_type;
+   typedef typename boost::mpl::if_c<shift == 0,
+      typename recursive_packed_type::next_type,
+      recursive_packed_type>::type pack_type;
+   typedef typename combine_value_to_pack<pack_type, value_to_add>::type type;
+};
+template <char NextChar>
+struct pack_values<NextChar>
+{
+   static constexpr limb_type value_to_add = hex_value<NextChar>::value;
+
+   typedef value_pack<value_to_add> type;
+};
+
+template <class T>
+struct strip_leading_zeros_from_pack;
+template <limb_type...PACK>
+struct strip_leading_zeros_from_pack<value_pack<PACK...> >
+{
+   typedef value_pack<PACK...> type;
+};
+template <limb_type...PACK>
+struct strip_leading_zeros_from_pack<value_pack<0u, PACK...> >
+{
+   typedef typename strip_leading_zeros_from_pack<value_pack<PACK...> >::type type;
+};
+
+template <limb_type v, class PACK>
+struct append_value_to_pack;
+template <limb_type v, limb_type...PACK>
+struct append_value_to_pack<v, value_pack<PACK...> >
+{
+   typedef value_pack<PACK..., v> type;
+};
+
+template <class T>
+struct reverse_value_pack;
+template <limb_type v, limb_type...VALUES>
+struct reverse_value_pack<value_pack<v, VALUES...> >
+{
+   typedef typename reverse_value_pack<value_pack<VALUES...> >::type lead_values;
+   typedef typename append_value_to_pack<v, lead_values>::type type;
+};
+template <limb_type v>
+struct reverse_value_pack<value_pack<v> >
+{
+   typedef value_pack<v> type;
+};
+template <>
+struct reverse_value_pack<value_pack<> >
+{
+   typedef value_pack<> type;
+};
+
+template <char l1, char l2, char...STR>
+struct make_packed_value_from_str
+{
+   BOOST_STATIC_ASSERT_MSG(l1 == '0', "Multi-precision integer literals must be in hexadecimal notation.");
+   BOOST_STATIC_ASSERT_MSG((l2 == 'X') || (l2 == 'x'), "Multi-precision integer literals must be in hexadecimal notation.");
+   typedef typename pack_values<STR...>::type packed_type;
+   typedef typename strip_leading_zeros_from_pack<packed_type>::type stripped_type;
+   typedef typename reverse_value_pack<stripped_type>::type type;
+};
+
+template <class Pack, class B>
+struct make_backend_from_pack
+{
+   static constexpr Pack p = {};
+   static constexpr B value = p;
+};
+
+template <class Pack, class B>
+constexpr B make_backend_from_pack<Pack, B>::value;
+
+template <unsigned Digits>
+struct signed_cpp_int_literal_result_type
+{
+   static constexpr unsigned bits = Digits * 4;
+   typedef boost::multiprecision::backends::cpp_int_backend<bits, bits, signed_magnitude, unchecked, void> backend_type;
+   typedef number<backend_type, et_off> number_type;
+};
+
+template <unsigned Digits>
+struct unsigned_cpp_int_literal_result_type
+{
+   static constexpr unsigned bits = Digits * 4;
+   typedef boost::multiprecision::backends::cpp_int_backend<bits, bits, unsigned_magnitude, unchecked, void> backend_type;
+   typedef number<backend_type, et_off> number_type;
+};
+
+}
+
+template <char... STR>
+constexpr typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::number_type operator "" _cppi()
+{
+   typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;
+   return boost::multiprecision::literals::detail::make_backend_from_pack<pt, typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::backend_type>::value;
+}
+
+template <char... STR>
+constexpr typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::number_type operator "" _cppui()
+{
+   typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;
+   return boost::multiprecision::literals::detail::make_backend_from_pack<pt, typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::backend_type>::value;
+}
+
+#define BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(Bits)\
+template <char... STR> \
+constexpr boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > operator "" BOOST_JOIN(_cppi, Bits)()\
+{\
+   typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;\
+   return boost::multiprecision::literals::detail::make_backend_from_pack<\
+      pt, \
+      boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> \
+   >::value;\
+}\
+template <char... STR> \
+constexpr boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > operator "" BOOST_JOIN(_cppui, Bits)()\
+{\
+   typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;\
+   return boost::multiprecision::literals::detail::make_backend_from_pack<\
+      pt, \
+      boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>\
+   >::value;\
+}\
+
+BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(128)
+BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(256)
+BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(512)
+BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(1024)
+
+}
+
+//
+// Overload unary minus operator for constexpr use:
+//
+template <unsigned MinBits, cpp_int_check_type Checked>
+constexpr number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>
+   operator - (const number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>& a)
+{
+   return cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>(a.backend(), boost::multiprecision::literals::detail::make_negate_tag());
+}
+template <unsigned MinBits, cpp_int_check_type Checked>
+constexpr number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>
+   operator - (number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>&& a)
+{
+   return cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>(static_cast<const number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>&>(a).backend(), boost::multiprecision::literals::detail::make_negate_tag());
+}
+
+}} // namespaces
+
+#endif // BOOST_MP_CPP_INT_CORE_HPP
+
@@ -0,0 +1,46 @@
+
+#ifndef BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED
+#define BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/vector/vector10_c.hpp>
+#   include <boost/mpl/vector/vector20.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER vector20_c.hpp
+#   include <boost/mpl/vector/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/aux_/config/typeof.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+
+namespace boost { namespace mpl {
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(11, 20, <boost/mpl/vector/aux_/numbered_c.hpp>))
+#   include BOOST_PP_ITERATE()
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#endif // BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED
@@ -0,0 +1,52 @@
+//  (C) Copyright Gennadiy Rozental 2001.
+//  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/test for the library home page.
+//
+//  File        : $RCSfile$
+//
+//  Version     : $Revision$
+//
+//  Description : OF_XML report formatter implementation
+// ***************************************************************************
+
+#ifndef BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER
+#define BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER
+
+// Boost.Test
+#include <boost/test/detail/global_typedef.hpp>
+#include <boost/test/results_reporter.hpp>
+
+#include <boost/test/detail/suppress_warnings.hpp>
+
+//____________________________________________________________________________//
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+// ************************************************************************** //
+// **************              xml_report_formatter            ************** //
+// ************************************************************************** //
+
+class xml_report_formatter : public results_reporter::format {
+public:
+    // Formatter interface
+    void    results_report_start( std::ostream& ostr );
+    void    results_report_finish( std::ostream& ostr );
+
+    void    test_unit_report_start( test_unit const&, std::ostream& ostr );
+    void    test_unit_report_finish( test_unit const&, std::ostream& ostr );
+
+    void    do_confirmation_report( test_unit const&, std::ostream& ostr );
+};
+
+} // namespace output
+} // namespace unit_test
+} // namespace boost
+
+#include <boost/test/detail/enable_warnings.hpp>
+
+#endif // BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER
@@ -0,0 +1,74 @@
+=== Frequency Calibration
+
+Many _WSJT-X_ capabilities depend on signal-detection bandwidths no
+more than a few Hz.  Frequency accuracy and stability are therefore
+unusually important.  We provide tools to enable accurate frequency
+calibration of your radio, as well as precise frequency measurement of
+on-the-air signals.  The calibration procedure works by automatically
+cycling your CAT-controlled radio through a series of preset
+frequencies of carrier-based signals at reliably known frequencies,
+measuring the error in dial frequency for each signal.
+
+You will probably find it convenient to define and use a special
+<<CONFIG-MENU,Configuration>> dedicated to frequency calibration.
+Then complete the following steps, as appropriate for your system.
+
+- Switch to FreqCal mode
+
+- In the _Working Frequencies_ box on the *Settings -> Frequencies*
+tab, delete any default frequencies for *FreqCal* mode that are not
+relevant for your location.  You may want to replace some of them with
+reliably known frequencies receivable at your location.
+
+TIP: We find major-city AM broadcast stations generally serve well as
+frequency calibrators at the low frequency end of the spectrum.  In
+North America we also use the standard time-and-frequency broadcasts
+of WWV at 2.500, 5.000, 10.000, 15.000, and 20.000 MHz, and CHU at
+3.330, 7.850, and 14.670 MHz.  Similar shortwave signals are available
+in other parts of the world.
+
+- During the calibration procedure, the radio's USB dial frequency is
+offset 1500 Hz below each *FreqCal* entry in the default frequencies
+list.  As shown in the screen shot below, detected signal carriers
+therefore appear at about 1500 Hz in the WSJT-X waterfall.
+
+image::FreqCal.png[align="left",alt="FreqCal"]
+
+With modern synthesized radios, small measured offsets from 1500 Hz
+will exhibit a straight-line dependence on frequency.  You can
+approximate the calibration of your radio by simply dividing the
+measured frequency offset (in Hz) at the highest reliable frequency by
+the nominal frequency itself (in MHz).  For example, the 20 MHz
+measurement for WWV shown above produced a measured tone offset of
+24.6 Hz, displayed in the _WSJT-X_ decoded text window.  The resulting
+calibration constant is 24.6/20=1.23 parts per million.  This number
+may be entered as *Slope* on the *settings -> Frequencies* tab.
+
+A more precise calibration can be effected by fitting the intercept
+and slope of a straight line to the whole sequence of calibration
+measurements, as shown for these measurements in the graph plotted
+below.  Software tools for completing this task are included with the
+_WSJT-X_ installation, and detailed instructions for their use are
+available at https://physics.princeton.edu/pulsar/k1jt/FMT_User.pdf.
+Using these tools and no specialized hardware beyond your
+CAT-interfaced radio, you can calibrate the radio to better than 1 Hz
+and compete very effectively in the ARRL's periodic Frequency
+Measuring Tests.
+
+image::FreqCal_Graph.png[align="left",alt="FreqCal_Graph"]
+
+=== Reference Spectrum
+
+WSJT-X provides a tool that can be used to determine the detailed
+shape of your receiver's passband.  Disconnect your antenna or tune to
+a quiet frequency with no signals.  With WSJT-X running in one of the
+slow modes, select *Measure reference spectrum* from the *Tools* menu.
+Wait for about a minute and then hit the *Stop* button.  A file named
+`refspec.dat` will appear in your log directory.  
+
+ [ ... TBD ... ]
+
+=== Equalization
+
+ [ ... TBD ... ]
+
@@ -0,0 +1,267 @@
+# /* **************************************************************************
+#  *                                                                          *
+#  *     (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. */
+#
+# include <boost/preprocessor/slot/detail/shared.hpp>
+#
+# undef BOOST_PP_SLOT_2
+#
+# undef BOOST_PP_SLOT_2_DIGIT_1
+# undef BOOST_PP_SLOT_2_DIGIT_2
+# undef BOOST_PP_SLOT_2_DIGIT_3
+# undef BOOST_PP_SLOT_2_DIGIT_4
+# undef BOOST_PP_SLOT_2_DIGIT_5
+# undef BOOST_PP_SLOT_2_DIGIT_6
+# undef BOOST_PP_SLOT_2_DIGIT_7
+# undef BOOST_PP_SLOT_2_DIGIT_8
+# undef BOOST_PP_SLOT_2_DIGIT_9
+# undef BOOST_PP_SLOT_2_DIGIT_10
+#
+# if BOOST_PP_SLOT_TEMP_10 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_10 0
+# elif BOOST_PP_SLOT_TEMP_10 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_10 1
+# elif BOOST_PP_SLOT_TEMP_10 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_10 2
+# elif BOOST_PP_SLOT_TEMP_10 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_10 3
+# elif BOOST_PP_SLOT_TEMP_10 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_10 4
+# elif BOOST_PP_SLOT_TEMP_10 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_10 5
+# elif BOOST_PP_SLOT_TEMP_10 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_10 6
+# elif BOOST_PP_SLOT_TEMP_10 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_10 7
+# elif BOOST_PP_SLOT_TEMP_10 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_10 8
+# elif BOOST_PP_SLOT_TEMP_10 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_10 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_9 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_9 0
+# elif BOOST_PP_SLOT_TEMP_9 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_9 1
+# elif BOOST_PP_SLOT_TEMP_9 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_9 2
+# elif BOOST_PP_SLOT_TEMP_9 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_9 3
+# elif BOOST_PP_SLOT_TEMP_9 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_9 4
+# elif BOOST_PP_SLOT_TEMP_9 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_9 5
+# elif BOOST_PP_SLOT_TEMP_9 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_9 6
+# elif BOOST_PP_SLOT_TEMP_9 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_9 7
+# elif BOOST_PP_SLOT_TEMP_9 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_9 8
+# elif BOOST_PP_SLOT_TEMP_9 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_9 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_8 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_8 0
+# elif BOOST_PP_SLOT_TEMP_8 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_8 1
+# elif BOOST_PP_SLOT_TEMP_8 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_8 2
+# elif BOOST_PP_SLOT_TEMP_8 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_8 3
+# elif BOOST_PP_SLOT_TEMP_8 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_8 4
+# elif BOOST_PP_SLOT_TEMP_8 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_8 5
+# elif BOOST_PP_SLOT_TEMP_8 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_8 6
+# elif BOOST_PP_SLOT_TEMP_8 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_8 7
+# elif BOOST_PP_SLOT_TEMP_8 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_8 8
+# elif BOOST_PP_SLOT_TEMP_8 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_8 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_7 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_7 0
+# elif BOOST_PP_SLOT_TEMP_7 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_7 1
+# elif BOOST_PP_SLOT_TEMP_7 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_7 2
+# elif BOOST_PP_SLOT_TEMP_7 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_7 3
+# elif BOOST_PP_SLOT_TEMP_7 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_7 4
+# elif BOOST_PP_SLOT_TEMP_7 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_7 5
+# elif BOOST_PP_SLOT_TEMP_7 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_7 6
+# elif BOOST_PP_SLOT_TEMP_7 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_7 7
+# elif BOOST_PP_SLOT_TEMP_7 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_7 8
+# elif BOOST_PP_SLOT_TEMP_7 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_7 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_6 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_6 0
+# elif BOOST_PP_SLOT_TEMP_6 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_6 1
+# elif BOOST_PP_SLOT_TEMP_6 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_6 2
+# elif BOOST_PP_SLOT_TEMP_6 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_6 3
+# elif BOOST_PP_SLOT_TEMP_6 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_6 4
+# elif BOOST_PP_SLOT_TEMP_6 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_6 5
+# elif BOOST_PP_SLOT_TEMP_6 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_6 6
+# elif BOOST_PP_SLOT_TEMP_6 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_6 7
+# elif BOOST_PP_SLOT_TEMP_6 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_6 8
+# elif BOOST_PP_SLOT_TEMP_6 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_6 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_5 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_5 0
+# elif BOOST_PP_SLOT_TEMP_5 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_5 1
+# elif BOOST_PP_SLOT_TEMP_5 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_5 2
+# elif BOOST_PP_SLOT_TEMP_5 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_5 3
+# elif BOOST_PP_SLOT_TEMP_5 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_5 4
+# elif BOOST_PP_SLOT_TEMP_5 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_5 5
+# elif BOOST_PP_SLOT_TEMP_5 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_5 6
+# elif BOOST_PP_SLOT_TEMP_5 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_5 7
+# elif BOOST_PP_SLOT_TEMP_5 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_5 8
+# elif BOOST_PP_SLOT_TEMP_5 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_5 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_4 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_4 0
+# elif BOOST_PP_SLOT_TEMP_4 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_4 1
+# elif BOOST_PP_SLOT_TEMP_4 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_4 2
+# elif BOOST_PP_SLOT_TEMP_4 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_4 3
+# elif BOOST_PP_SLOT_TEMP_4 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_4 4
+# elif BOOST_PP_SLOT_TEMP_4 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_4 5
+# elif BOOST_PP_SLOT_TEMP_4 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_4 6
+# elif BOOST_PP_SLOT_TEMP_4 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_4 7
+# elif BOOST_PP_SLOT_TEMP_4 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_4 8
+# elif BOOST_PP_SLOT_TEMP_4 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_4 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_3 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_3 0
+# elif BOOST_PP_SLOT_TEMP_3 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_3 1
+# elif BOOST_PP_SLOT_TEMP_3 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_3 2
+# elif BOOST_PP_SLOT_TEMP_3 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_3 3
+# elif BOOST_PP_SLOT_TEMP_3 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_3 4
+# elif BOOST_PP_SLOT_TEMP_3 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_3 5
+# elif BOOST_PP_SLOT_TEMP_3 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_3 6
+# elif BOOST_PP_SLOT_TEMP_3 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_3 7
+# elif BOOST_PP_SLOT_TEMP_3 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_3 8
+# elif BOOST_PP_SLOT_TEMP_3 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_3 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_2 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_2 0
+# elif BOOST_PP_SLOT_TEMP_2 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_2 1
+# elif BOOST_PP_SLOT_TEMP_2 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_2 2
+# elif BOOST_PP_SLOT_TEMP_2 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_2 3
+# elif BOOST_PP_SLOT_TEMP_2 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_2 4
+# elif BOOST_PP_SLOT_TEMP_2 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_2 5
+# elif BOOST_PP_SLOT_TEMP_2 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_2 6
+# elif BOOST_PP_SLOT_TEMP_2 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_2 7
+# elif BOOST_PP_SLOT_TEMP_2 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_2 8
+# elif BOOST_PP_SLOT_TEMP_2 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_2 9
+# endif
+#
+# if BOOST_PP_SLOT_TEMP_1 == 0
+#    define BOOST_PP_SLOT_2_DIGIT_1 0
+# elif BOOST_PP_SLOT_TEMP_1 == 1
+#    define BOOST_PP_SLOT_2_DIGIT_1 1
+# elif BOOST_PP_SLOT_TEMP_1 == 2
+#    define BOOST_PP_SLOT_2_DIGIT_1 2
+# elif BOOST_PP_SLOT_TEMP_1 == 3
+#    define BOOST_PP_SLOT_2_DIGIT_1 3
+# elif BOOST_PP_SLOT_TEMP_1 == 4
+#    define BOOST_PP_SLOT_2_DIGIT_1 4
+# elif BOOST_PP_SLOT_TEMP_1 == 5
+#    define BOOST_PP_SLOT_2_DIGIT_1 5
+# elif BOOST_PP_SLOT_TEMP_1 == 6
+#    define BOOST_PP_SLOT_2_DIGIT_1 6
+# elif BOOST_PP_SLOT_TEMP_1 == 7
+#    define BOOST_PP_SLOT_2_DIGIT_1 7
+# elif BOOST_PP_SLOT_TEMP_1 == 8
+#    define BOOST_PP_SLOT_2_DIGIT_1 8
+# elif BOOST_PP_SLOT_TEMP_1 == 9
+#    define BOOST_PP_SLOT_2_DIGIT_1 9
+# endif
+#
+# if BOOST_PP_SLOT_2_DIGIT_10
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_10(BOOST_PP_SLOT_2_DIGIT_10, BOOST_PP_SLOT_2_DIGIT_9, BOOST_PP_SLOT_2_DIGIT_8, BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_9
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_9(BOOST_PP_SLOT_2_DIGIT_9, BOOST_PP_SLOT_2_DIGIT_8, BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_8
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_8(BOOST_PP_SLOT_2_DIGIT_8, BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_7
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_7(BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_6
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_6(BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_5
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_5(BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_4
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_4(BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_3
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_3(BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# elif BOOST_PP_SLOT_2_DIGIT_2
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_2(BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1)
+# else
+#    define BOOST_PP_SLOT_2() BOOST_PP_SLOT_2_DIGIT_1
+# endif
@@ -0,0 +1,57 @@
+# /* **************************************************************************
+#  *                                                                          *
+#  *     (C) Copyright Edward Diener 2014.
+#  *     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_FACILITIES_IS_EMPTY_VARIADIC_HPP
+# define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# if BOOST_PP_VARIADICS
+#
+# include <boost/preprocessor/punctuation/is_begin_parens.hpp>
+# include <boost/preprocessor/facilities/detail/is_empty.hpp>
+#
+#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400
+#
+#define BOOST_PP_IS_EMPTY(param) \
+    BOOST_PP_DETAIL_IS_EMPTY_IIF \
+      ( \
+      BOOST_PP_IS_BEGIN_PARENS \
+        ( \
+        param \
+        ) \
+      ) \
+      ( \
+      BOOST_PP_IS_EMPTY_ZERO, \
+      BOOST_PP_DETAIL_IS_EMPTY_PROCESS \
+      ) \
+    (param) \
+/**/
+#define BOOST_PP_IS_EMPTY_ZERO(param) 0
+# else
+#define BOOST_PP_IS_EMPTY(...) \
+    BOOST_PP_DETAIL_IS_EMPTY_IIF \
+      ( \
+      BOOST_PP_IS_BEGIN_PARENS \
+        ( \
+        __VA_ARGS__ \
+        ) \
+      ) \
+      ( \
+      BOOST_PP_IS_EMPTY_ZERO, \
+      BOOST_PP_DETAIL_IS_EMPTY_PROCESS \
+      ) \
+    (__VA_ARGS__) \
+/**/
+#define BOOST_PP_IS_EMPTY_ZERO(...) 0
+# endif /* BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 */
+# endif /* BOOST_PP_VARIADICS */
+# endif /* BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP */
@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED
+#define BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/empty_fwd.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/list/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct empty_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+        : not_<typename List::size>
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED
@@ -0,0 +1,176 @@
+//  (C) Copyright John Maddock 2007.
+//  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)
+//
+//  This file is machine generated, do not edit by hand
+
+// Polynomial evaluation using second order Horners rule
+#ifndef BOOST_MATH_TOOLS_RAT_EVAL_12_HPP
+#define BOOST_MATH_TOOLS_RAT_EVAL_12_HPP
+
+namespace boost{ namespace math{ namespace tools{ namespace detail{
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V)
+{
+   return static_cast<V>(0);
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V)
+{
+   return static_cast<V>(a[0]) / static_cast<V>(b[0]);
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V)
+{
+   return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0]));
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V)
+{
+   return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0]));
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V)
+{
+   return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0]));
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>(((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x) / ((b[4] * x2 + b[2]) * x2 + b[0] + (b[3] * x2 + b[1]) * x));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>(((a[0] * z2 + a[2]) * z2 + a[4] + (a[1] * z2 + a[3]) * z) / ((b[0] * z2 + b[2]) * z2 + b[4] + (b[1] * z2 + b[3]) * z));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>((((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]) / (((b[5] * x2 + b[3]) * x2 + b[1]) * x + (b[4] * x2 + b[2]) * x2 + b[0]));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>((((a[0] * z2 + a[2]) * z2 + a[4]) * z + (a[1] * z2 + a[3]) * z2 + a[5]) / (((b[0] * z2 + b[2]) * z2 + b[4]) * z + (b[1] * z2 + b[3]) * z2 + b[5]));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>((((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x) / (((b[6] * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + ((b[5] * x2 + b[3]) * x2 + b[1]) * x));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6] + ((a[1] * z2 + a[3]) * z2 + a[5]) * z) / (((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6] + ((b[1] * z2 + b[3]) * z2 + b[5]) * z));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>(((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / ((((b[7] * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + ((b[6] * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>(((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z + ((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) / ((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z + ((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>(((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x) / ((((b[8] * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + (((b[7] * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>(((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8] + (((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z) / ((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8] + (((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>((((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / (((((b[9] * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + (((b[8] * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z + (((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) / (((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z + (((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>((((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x) / (((((b[10] * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + ((((b[9] * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10] + ((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z) / (((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10] + ((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z));
+   }
+}
+
+template <class T, class U, class V>
+inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V)
+{
+   if(x <= 1)
+   {
+      V x2 = x * x;
+      return static_cast<V>(((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / ((((((b[11] * x2 + b[9]) * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + ((((b[10] * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
+   }
+   else
+   {
+      V z = 1 / x;
+      V z2 = 1 / (x * x);
+      return static_cast<V>(((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10]) * z + ((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z2 + a[11]) / ((((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10]) * z + ((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z2 + b[11]));
+   }
+}
+
+
+}}}} // namespaces
+
+#endif // include guard
+
@@ -0,0 +1,64 @@
+// Status=review
+The following buttons appear just under the decoded text windows on
+the main screen:
+
+//.Main UI 
+image::main-ui-controls.png[align="left",width=650,alt="Main UI Controls"]
+
+* *Log QSO* raises a dialog window pre-filled with known information
+about a QSO you have nearly completed.  You can edit or add to this
+information before clicking *OK* to log the QSO.  If you check *Prompt
+me to log QSO* on the *Settings -> Reporting* tab, the program will
+raise the confirmation screen automatically when you send a message
+containing +73+.  *Start Date* and *Start Time* are set when you click
+to send the *Tx 2* or *Tx 3* message, and backed up by one or two
+sequence lengths, respectively.  (Note that the actual start time may
+have been earlier if repeats of early transmissions were required.)
+End date and time are set when the *Log QSO* screen is invoked.
+
+//.Log QSO Window
+image::log-qso.png[align="center",alt="Log QSO"]
+
+* *Stop* will terminate normal data acquisition in case you want to
+freeze the waterfall or open and explore a previously recorded audio
+file.
+
+* *Monitor* toggles normal receive operation on or off.  This button
+is highlighted in green when the _WSJT-X_ is receiving.  If you are
+using CAT control, toggling *Monitor* OFF relinquishes control of the
+rig; if *Monitor returns to last used frequency* is selected on the
+*Settings | General* tab, toggling *Monitor* back ON will return to
+the original frequency.
+
+* *Erase* clears the right-hand decoded text window. 
+Double-clicking *Erase* clears both text windows.
+
+TIP: Right-clicking on either text window brings up a context menu
+with several options (including *Erase*) which operate on that window
+alone.
+
+* *Clear Avg* is present only in modes that support message averaging.
+It provides a way to erase the accumulating information, thus
+preparing to start a new average.
+
+* *Decode* tells the program to repeat the decoding procedure at the
+Rx frequency (green marker on waterfall scale), using the most recently
+completed sequence of received data.  
+
+* *Enable Tx* toggles automatic T/R sequencing mode on or off and
+highlights the button in red when ON.  A transmission will start at
+the beginning of the selected (odd or even) sequence, or immediately
+if appropriate.  Toggling the button to OFF during a transmission
+allows the current transmission to finish.
+
+* *Halt Tx* terminates a transmission immediately and disables
+automatic T/R sequencing.
+
+* *Tune* toggles the program into Tx mode and generates an unmodulated
+carrier at the specified Tx frequency (red marker on waterfall scale).
+This process is useful for adjusting an antenna tuner or tuning an
+amplifier.  The button is highlighted in red while *Tune* is active.
+Toggle the button a second time or click *Halt Tx* to terminate the
+*Tune* process.  Note that activating *Tune* interrupts a receive
+sequence and will prevent decoding during that sequence.
+